<!DOCTYPE HTML>
<html lang="zh-CN">


<head>
    <meta charset="utf-8">
    <meta name="keywords" content="Java面试题（分布式微服务篇）, Angus">
    <meta name="description" content="Java面试分布式与微服务题型相关讲解">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
    <meta name="renderer" content="webkit|ie-stand|ie-comp">
    <meta name="mobile-web-app-capable" content="yes">
    <meta name="format-detection" content="telephone=no">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
    <meta name="referrer" content="no-referrer-when-downgrade">
    <!-- Global site tag (gtag.js) - Google Analytics -->


    

    <title>Java面试题（分布式微服务篇） | Angus</title>
    <link rel="icon" type="image/png" href="/favicon.png">

    <link rel="stylesheet" type="text/css" href="/libs/awesome/css/all.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/materialize/materialize.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/aos/aos.css">
    <link rel="stylesheet" type="text/css" href="/libs/animate/animate.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/lightGallery/css/lightgallery.min.css">
    <link rel="stylesheet" type="text/css" href="/css/matery.css">
    <link rel="stylesheet" type="text/css" href="/css/my.css">

    <script src="/libs/jquery/jquery-3.6.0.min.js"></script>

<meta name="generator" content="Hexo 6.1.0">
<style>.github-emoji { position: relative; display: inline-block; width: 1.2em; min-height: 1.2em; overflow: hidden; vertical-align: top; color: transparent; }  .github-emoji > span { position: relative; z-index: 10; }  .github-emoji img, .github-emoji .fancybox { margin: 0 !important; padding: 0 !important; border: none !important; outline: none !important; text-decoration: none !important; user-select: none !important; cursor: auto !important; }  .github-emoji img { height: 1.2em !important; width: 1.2em !important; position: absolute !important; left: 50% !important; top: 50% !important; transform: translate(-50%, -50%) !important; user-select: none !important; cursor: auto !important; } .github-emoji-fallback { color: inherit; } .github-emoji-fallback img { opacity: 0 !important; }</style>
<link rel="alternate" href="/atom.xml" title="Angus" type="application/atom+xml">
<link rel="stylesheet" href="/css/prism-tomorrow.css" type="text/css"></head>


<body>
    <header class="navbar-fixed">
    <nav id="headNav" class="bg-color nav-transparent">
        <div id="navContainer" class="nav-wrapper container">
            <div class="brand-logo">
                <a href="/" class="waves-effect waves-light">
                    
                    <img src="/medias/logo.png" class="logo-img" alt="LOGO">
                    
                    <span class="logo-span">Angus</span>
                </a>
            </div>
            

<a href="#" data-target="mobile-nav" class="sidenav-trigger button-collapse"><i class="fas fa-bars"></i></a>
<ul class="right nav-menu">
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/" class="waves-effect waves-light">
      
      <i class="fas fa-home" style="zoom: 0.6;"></i>
      
      <span>首页</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/tags" class="waves-effect waves-light">
      
      <i class="fas fa-tags" style="zoom: 0.6;"></i>
      
      <span>标签</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/categories" class="waves-effect waves-light">
      
      <i class="fas fa-bookmark" style="zoom: 0.6;"></i>
      
      <span>分类</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/archives" class="waves-effect waves-light">
      
      <i class="fas fa-archive" style="zoom: 0.6;"></i>
      
      <span>归档</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/about" class="waves-effect waves-light">
      
      <i class="fas fa-user-circle" style="zoom: 0.6;"></i>
      
      <span>关于</span>
    </a>
    
  </li>
  
  <li class="hide-on-med-and-down nav-item">
    
    <a href="/contact" class="waves-effect waves-light">
      
      <i class="fas fa-comments" style="zoom: 0.6;"></i>
      
      <span>留言板</span>
    </a>
    
  </li>
  
  <li>
    <a href="#searchModal" class="modal-trigger waves-effect waves-light">
      <i id="searchIcon" class="fas fa-search" title="搜索" style="zoom: 0.85;"></i>
    </a>
  </li>
</ul>


<div id="mobile-nav" class="side-nav sidenav">

    <div class="mobile-head bg-color">
        
        <img src="/medias/logo.png" class="logo-img circle responsive-img">
        
        <div class="logo-name">Angus</div>
        <div class="logo-desc">
            
            never give up!
            
        </div>
    </div>

    <ul class="menu-list mobile-menu-list">
        
        <li class="m-nav-item">
	  
		<a href="/" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-home"></i>
			
			首页
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/tags" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-tags"></i>
			
			标签
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/categories" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-bookmark"></i>
			
			分类
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/archives" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-archive"></i>
			
			归档
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/about" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-user-circle"></i>
			
			关于
		</a>
          
        </li>
        
        <li class="m-nav-item">
	  
		<a href="/contact" class="waves-effect waves-light">
			
			    <i class="fa-fw fas fa-comments"></i>
			
			留言板
		</a>
          
        </li>
        
        
        <li><div class="divider"></div></li>
        <li>
            <a href="https://github.com/Monkey-chao/Monkey-chao.github.io.git" class="waves-effect waves-light" target="_blank">
                <i class="fab fa-github-square fa-fw"></i>Fork Me
            </a>
        </li>
        
    </ul>
</div>


        </div>

        
            <style>
    .nav-transparent .github-corner {
        display: none !important;
    }

    .github-corner {
        position: absolute;
        z-index: 10;
        top: 0;
        right: 0;
        border: 0;
        transform: scale(1.1);
    }

    .github-corner svg {
        color: #0f9d58;
        fill: #fff;
        height: 64px;
        width: 64px;
    }

    .github-corner:hover .octo-arm {
        animation: a 0.56s ease-in-out;
    }

    .github-corner .octo-arm {
        animation: none;
    }

    @keyframes a {
        0%,
        to {
            transform: rotate(0);
        }
        20%,
        60% {
            transform: rotate(-25deg);
        }
        40%,
        80% {
            transform: rotate(10deg);
        }
    }
</style>

<a href="https://github.com/Monkey-chao/Monkey-chao.github.io.git" class="github-corner tooltipped hide-on-med-and-down" target="_blank"
   data-tooltip="Fork Me" data-position="left" data-delay="50">
    <svg viewBox="0 0 250 250" aria-hidden="true">
        <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
        <path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2"
              fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path>
        <path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z"
              fill="currentColor" class="octo-body"></path>
    </svg>
</a>
        
    </nav>

</header>

    



<div class="bg-cover pd-header post-cover" style="background-image: url('/medias/featureimages/23.jpg')">
    <div class="container" style="right: 0px;left: 0px;">
        <div class="row">
            <div class="col s12 m12 l12">
                <div class="brand">
                    <h1 class="description center-align post-title">Java面试题（分布式微服务篇）</h1>
                </div>
            </div>
        </div>
    </div>
</div>




<main class="post-container content">

    
    <link rel="stylesheet" href="/libs/tocbot/tocbot.css">
<style>
    #articleContent h1::before,
    #articleContent h2::before,
    #articleContent h3::before,
    #articleContent h4::before,
    #articleContent h5::before,
    #articleContent h6::before {
        display: block;
        content: " ";
        height: 100px;
        margin-top: -100px;
        visibility: hidden;
    }

    #articleContent :focus {
        outline: none;
    }

    .toc-fixed {
        position: fixed;
        top: 64px;
    }

    .toc-widget {
        width: 345px;
        padding-left: 20px;
    }

    .toc-widget .toc-title {
        padding: 35px 0 15px 17px;
        font-size: 1.5rem;
        font-weight: bold;
        line-height: 1.5rem;
    }

    .toc-widget ol {
        padding: 0;
        list-style: none;
    }

    #toc-content {
        padding-bottom: 30px;
        overflow: auto;
    }

    #toc-content ol {
        padding-left: 10px;
    }

    #toc-content ol li {
        padding-left: 10px;
    }

    #toc-content .toc-link:hover {
        color: #42b983;
        font-weight: 700;
        text-decoration: underline;
    }

    #toc-content .toc-link::before {
        background-color: transparent;
        max-height: 25px;

        position: absolute;
        right: 23.5vw;
        display: block;
    }

    #toc-content .is-active-link {
        color: #42b983;
    }

    #floating-toc-btn {
        position: fixed;
        right: 15px;
        bottom: 76px;
        padding-top: 15px;
        margin-bottom: 0;
        z-index: 998;
    }

    #floating-toc-btn .btn-floating {
        width: 48px;
        height: 48px;
    }

    #floating-toc-btn .btn-floating i {
        line-height: 48px;
        font-size: 1.4rem;
    }
</style>
<div class="row">
    <div id="main-content" class="col s12 m12 l9">
        <!-- 文章内容详情 -->
<div id="artDetail">
    <div class="card">
        <div class="card-content article-info">
            <div class="row tag-cate">
                <div class="col s7">
                    
                    <div class="article-tag">
                        
                            <a href="/tags/Java/">
                                <span class="chip bg-color">Java</span>
                            </a>
                        
                            <a href="/tags/%E9%9D%A2%E8%AF%95/">
                                <span class="chip bg-color">面试</span>
                            </a>
                        
                            <a href="/tags/%E5%88%86%E5%B8%83%E5%BC%8F%E4%B8%8E%E5%BE%AE%E6%9C%8D%E5%8A%A1/">
                                <span class="chip bg-color">分布式与微服务</span>
                            </a>
                        
                    </div>
                    
                </div>
                <div class="col s5 right-align">
                    
                    <div class="post-cate">
                        <i class="fas fa-bookmark fa-fw icon-category"></i>
                        
                            <a href="/categories/%E9%9D%A2%E8%AF%95%E5%AE%9D%E5%85%B8/" class="post-category">
                                面试宝典
                            </a>
                        
                    </div>
                    
                </div>
            </div>

            <div class="post-info">
                
                <div class="post-date info-break-policy">
                    <i class="far fa-calendar-minus fa-fw"></i>发布日期:&nbsp;&nbsp;
                    2022-08-10
                </div>
                

                
                <div class="post-date info-break-policy">
                    <i class="far fa-calendar-check fa-fw"></i>更新日期:&nbsp;&nbsp;
                    2022-08-10
                </div>
                

                
                <div class="info-break-policy">
                    <i class="far fa-file-word fa-fw"></i>文章字数:&nbsp;&nbsp;
                    13.3k
                </div>
                

                
                <div class="info-break-policy">
                    <i class="far fa-clock fa-fw"></i>阅读时长:&nbsp;&nbsp;
                    47 分
                </div>
                

                
                    <div id="busuanzi_container_page_pv" class="info-break-policy">
                        <i class="far fa-eye fa-fw"></i>阅读次数:&nbsp;&nbsp;
                        <span id="busuanzi_value_page_pv"></span>
                    </div>
				
            </div>
        </div>
        <hr class="clearfix">

        

        

        <div class="card-content article-card-content">
            <div id="articleContent">
                <h1 id="Java面试题（分布式微服务篇）"><a href="#Java面试题（分布式微服务篇）" class="headerlink" title="Java面试题（分布式微服务篇）"></a>Java面试题（分布式微服务篇）</h1><h2 id="一、什么是CAP理论"><a href="#一、什么是CAP理论" class="headerlink" title="一、什么是CAP理论"></a>一、什么是CAP理论</h2><p>CAP理论是分布式领域中⾮常重要的⼀个指导理论，C（Consistency）表示强⼀致性， A（Availability）表示可⽤性，P（Partition Tolerance）表示分区容错性，CAP理论指出在⽬前的硬件条件下，⼀个分布式系统是必须要保证分区容错性的，⽽在这个前提下，分布式系统要么保证CP，要么 保证AP，⽆法同时保证CAP。 </p>
<p>分区容错性表示，⼀个系统虽然是分布式的，但是对外看上去应该是⼀个整体，不能由于分布式系统内 部的某个结点挂点，或⽹络出现了故障，⽽导致系统对外出现异常。所以，对于分布式系统⽽⾔是⼀定 要保证分区容错性的。 </p>
<p>强⼀致性表示，⼀个分布式系统中各个结点之间能及时的同步数据，在数据同步过程中，是不能对外提 供服务的，不然就会造成数据不⼀致，所以强⼀致性和可⽤性是不能同时满⾜的。 </p>
<p>可⽤性表示，⼀个分布式系统对外要保证可⽤。</p>
<h2 id="二、什么是BASE理论"><a href="#二、什么是BASE理论" class="headerlink" title="二、什么是BASE理论"></a>二、什么是BASE理论</h2><p>由于不能同时满⾜CAP，所以出现了BASE理论： </p>
<ol>
<li><p>BA：Basically Available，表示基本可⽤，表示可以允许⼀定程度的不可⽤，⽐如由于系统故障， 请求时间变⻓，或者由于系统故障导致部分⾮核⼼功能不可⽤，都是允许的 </p>
</li>
<li><p>S：Soft state：表示分布式系统可以处于⼀种中间状态，⽐如数据正在同步 </p>
</li>
<li><p>E：Eventually consistent，表示最终⼀致性，不要求分布式系统数据实时达到⼀致，允许在经过⼀ 段时间后再达到⼀致，在达到⼀致过程中，系统也是可⽤的</p>
</li>
</ol>
<h2 id="三、什么是RPC"><a href="#三、什么是RPC" class="headerlink" title="三、什么是RPC"></a>三、什么是RPC</h2><p>RPC，表示远程过程调⽤，对于Java这种⾯试对象语⾔，也可以理解为远程⽅法调⽤，RPC调⽤和 HTTP调⽤是有区别的，RPC表示的是⼀种调⽤远程⽅法的⽅式，可以使⽤HTTP协议、或直接基于TCP协议来实现RPC，在Java中，我们可以通过直接使⽤某个服务接⼝的代理对象来执⾏⽅法，⽽底层则通过构造HTTP请求来调⽤远端的⽅法，所以，有⼀种说法是RPC协议是HTTP协议之上的⼀种协议，也是可以理解的。 </p>
<h2 id="四、数据⼀致性模型有哪些"><a href="#四、数据⼀致性模型有哪些" class="headerlink" title="四、数据⼀致性模型有哪些"></a>四、数据⼀致性模型有哪些</h2><ul>
<li><p>强⼀致性：当更新操作完成之后，任何多个后续进程的访问都会返回最新的更新过的值，这种是对 ⽤户 最友好的，就是⽤户上⼀次写什么，下⼀次就保证能读到什么。根据 CAP理论，这种实现需 要牺牲可⽤性。 </p>
</li>
<li><p>弱⼀致性：系统在数据写⼊成功之后，不承诺⽴即可以读到最新写⼊的值，也不会具体的承诺多久 之后 可以读到。⽤户读到某⼀操作对系统数据的更新需要⼀段时间，我们称这段时间为“不⼀致性 窗⼝”。 </p>
</li>
<li><p>最终⼀致性：最终⼀致性是弱⼀致性的特例，强调的是所有的数据副本，在经过⼀段时间的同步之 后， 最终都能够达到⼀个⼀致的状态。因此，最终⼀致性的本质是需要系统保证最终数据能够达 到⼀致，⽽ 不需要实时保证系统数据的强⼀致性。到达最终⼀致性的时间 ，就是不⼀致窗⼝时 间，在没有故障发⽣的前提下，不⼀致窗⼝的时间主要受通信延迟，系统负载和复制副本的个数影 响。最终⼀致性模型根据其提供的不同保证可以划分为更多的模型，包括因果⼀致性和会话⼀致性 等。</p>
</li>
</ul>
<h2 id="五、分布式ID是什么？有哪些解决⽅案？"><a href="#五、分布式ID是什么？有哪些解决⽅案？" class="headerlink" title="五、分布式ID是什么？有哪些解决⽅案？"></a>五、分布式ID是什么？有哪些解决⽅案？</h2><p>在开发中，我们通常会需要⼀个唯⼀ID来标识数据，如果是单体架构，我们可以通过数据库的主键，或 直接在内存中维护⼀个⾃增数字来作为ID都是可以的，但对于⼀个分布式系统，就会有可能会出现ID冲 突，此时有以下解决⽅案： </p>
<ol>
<li><p>uuid，这种⽅案复杂度最低，但是会影响存储空间和性能 </p>
</li>
<li><p>利⽤单机数据库的⾃增主键，作为分布式ID的⽣成器，复杂度适中，ID⻓度较之uuid更短，但是受 到单机数据库性能的限制，并发量⼤的时候，此⽅案也不是最优⽅案 </p>
</li>
<li><p>利⽤redis、zookeeper的特性来⽣成id，⽐如redis的⾃增命令、zookeeper的顺序节点，这种⽅案 和单机数据库(mysql)相⽐，性能有所提⾼，可以适当选⽤ </p>
</li>
<li><p>雪花算法，⼀切问题如果能直接⽤算法解决，那就是最合适的，利⽤雪花算法也可以⽣成分布式 ID，底层原理就是通过某台机器在某⼀毫秒内对某⼀个数字⾃增，这种⽅案也能保证分布式架构中 的系统id唯⼀，但是只能保证趋势递增。业界存在tinyid、leaf等开源中间件实现了雪花算法。</p>
</li>
</ol>
<h2 id="六、分布式锁的使⽤场景是什么？有哪些实现⽅案？"><a href="#六、分布式锁的使⽤场景是什么？有哪些实现⽅案？" class="headerlink" title="六、分布式锁的使⽤场景是什么？有哪些实现⽅案？"></a>六、分布式锁的使⽤场景是什么？有哪些实现⽅案？</h2><p>在单体架构中，多个线程都是属于同⼀个进程的，所以在线程并发执⾏时，遇到资源竞争时，可以利⽤ ReentrantLock、synchronized等技术来作为锁，来控制共享资源的使⽤。 </p>
<p>⽽在分布式架构中，多个线程是可能处于不同进程中的，⽽这些线程并发执⾏遇到资源竞争时，利⽤ ReentrantLock、synchronized等技术是没办法来控制多个进程中的线程的，所以需要分布式锁，意思 就是，需要⼀个分布式锁⽣成器，分布式系统中的应⽤程序都可以来使⽤这个⽣成器所提供的锁，从⽽ 达到多个进程中的线程使⽤同⼀把锁。 </p>
<p>⽬前主流的分布式锁的实现⽅案有两种： </p>
<ol>
<li><p>zookeeper：利⽤的是zookeeper的临时节点、顺序节点、watch机制来实现的，zookeeper分布式 锁的特点是⾼⼀致性，因为zookeeper保证的是CP，所以由它实现的分布式锁更可靠，不会出现混 乱 </p>
</li>
<li><p>redis：利⽤redis的setnx、lua脚本、消费订阅等机制来实现的，redis分布式锁的特点是⾼可⽤， 因为redis保证的是AP，所以由它实现的分布式锁可能不可靠，不稳定（⼀旦redis中的数据出现了 不⼀致），可能会出现多个客户端同时加到锁的情况</p>
</li>
</ol>
<h2 id="七、什么是分布式事务？有哪些实现⽅案？"><a href="#七、什么是分布式事务？有哪些实现⽅案？" class="headerlink" title="七、什么是分布式事务？有哪些实现⽅案？"></a>七、什么是分布式事务？有哪些实现⽅案？</h2><p>在分布式系统中，⼀次业务处理可能需要多个应⽤来实现，⽐如⽤户发送⼀次下单请求，就涉及到订单 系统创建订单、库存系统减库存，⽽对于⼀次下单，订单创建与减库存应该是要同时成功或同时失败的，但在分布式系统中，如果不做处理，就很有可能出现订单创建成功，但是减库存失败，那么解决这 类问题，就需要⽤到分布式事务。常⽤解决⽅案有： </p>
<ol>
<li><p>本地消息表：创建订单时，将减库存消息加⼊在本地事务中，⼀起提交到数据库存⼊本地消息表， 然后调⽤库存系统，如果调⽤成功则修改本地消息状态为成功，如果调⽤库存系统失败，则由后台 定时任务从本地消息表中取出未成功的消息，重试调⽤库存系统 </p>
</li>
<li><p>消息队列：⽬前RocketMQ中⽀持事务消息，它的⼯作原理是： </p>
<p>a. ⽣产者订单系统先发送⼀条half消息到Broker，half消息对消费者⽽⾔是不可⻅的 </p>
<p>b. 再创建订单，根据创建订单成功与否，向Broker发送commit或rollback </p>
<p>c. 并且⽣产者订单系统还可以提供Broker回调接⼝，当Broker发现⼀段时间half消息没有收到任何操作命令，则会主动调此接⼝来查询订单是否创建成功 </p>
<p>d. ⼀旦half消息commit了，消费者库存系统就会来消费，如果消费成功，则消息销毁，分布式事 务成功结束 </p>
<p>e. 如果消费失败，则根据重试策略进⾏重试，最后还失败则进⼊死信队列，等待进⼀步处理 </p>
</li>
<li><p>Seata：阿⾥开源的分布式事务框架，⽀持AT、TCC等多种模式，底层都是基于两阶段提交理论来 实现的</p>
</li>
</ol>
<h2 id="八、什么是ZAB协议"><a href="#八、什么是ZAB协议" class="headerlink" title="八、什么是ZAB协议"></a>八、什么是ZAB协议</h2><p>ZAB协议是Zookeeper⽤来实现⼀致性的原⼦⼴播协议，该协议描述了Zookeeper是如何实现⼀致性 的，分为三个阶段： </p>
<ol>
<li><p>领导者选举阶段：从Zookeeper集群中选出⼀个节点作为Leader，所有的写请求都会由Leader节点 来处理 </p>
</li>
<li><p>数据同步阶段：集群中所有节点中的数据要和Leader节点保持⼀致，如果不⼀致则要进⾏同步 </p>
</li>
<li><p>请求⼴播阶段：当Leader节点接收到写请求时，会利⽤两阶段提交来⼴播该写请求，使得写请求像 事务⼀样在其他节点上执⾏，达到节点上的数据实时⼀致但值得注意的是，Zookeeper只是尽量的在达到强⼀致性，实际上仍然只是最终⼀致性的</p>
</li>
</ol>
<h2 id="九、简述paxos算法"><a href="#九、简述paxos算法" class="headerlink" title="九、简述paxos算法"></a>九、简述paxos算法</h2><p>Paxos算法解决的是⼀个分布式系统如何就某个值（决议）达成⼀致。⼀个典型的场景是，在⼀个分布 式数据库系统中，如果各个节点的初始状态⼀致，每个节点执⾏相同的操作序列，那么他们最后能够得 到⼀个⼀致的状态。为了保证每个节点执⾏相同的操作序列，需要在每⼀条指令上执⾏⼀个“⼀致性算法”以保证每个节点看到的指令⼀致。在Paxos算法中，有三种⻆⾊：Proposer (提议者),Acceptor（接受者），Learners（记录员）</p>
<p>Proposer提议者：只要Proposer发的提案Propose被半数以上的Acceptor接受，Proposer就认为该提 案例的value被选定了。 </p>
<p>Acceptor接受者：只要Acceptor接受了某个提案，Acceptor就认为该提案例的value被选定了Learner </p>
<p>记录员：Acceptor告诉Learner哪个value被选定，Learner就认为哪个value被选定。 Paxos算法分为两个阶段，具体如下： 阶段⼀ （preprae ）： </p>
<p>(a) Proposer收到client请求或者发现本地有未提交的值，选择⼀个提案编号 N，然后向半数以上的Acceptor发送编号为 N的Prepare请求。 </p>
<p>(b) Acceptor收到⼀个编号为 N的 Prepare请求，如果该轮paxos本节点已经有已提交的value记录，对⽐记录的编号和N，⼤于N则拒绝回应，否则返回该记录value及编号 没有已提交记录，判断本地是否有编号N1，N1&gt;N、则拒绝响应，否则将N1改为N（如果没有N1，则记录N），并响应prepare </p>
<p>阶段⼆ （accept）： </p>
<p>(a) 如果 Proposer收到半数以上 Acceptor对其发出的编号为 N的 Prepare请求的响应，那么它就会发送⼀个针对[N,V]提案的Accept请求给半数以上的 Acceptor。V就是收到的响应中编号最⼤的value ，如果响应中不包含任何value，那么V 就由 Proposer ⾃⼰决定。 </p>
<p>(b) 如果 Acceptor收到⼀个针对编号为 N的提案的 Accept请求，Acceptor对⽐本地的记录编号，如果⼩于等于N，则接受该值，并提交记录value。否则拒绝请求 </p>
<p>Proposer 如果收到的⼤多数Acceptor响应，则选定该value值，并同步给leaner，使未响应的Acceptor 达成⼀致 </p>
<p>活锁：accept时被拒绝，加⼤N，重新accept，此时另外⼀个proposer也进⾏相同操作，导致accept⼀ 致失败，⽆法完成算法 multi-paxos：区别于paxos只是确定⼀个值，multi-paxos可以确定多个值，收到accept请求后，则⼀ 定时间内不再accept其他节点的请求，以此保证后续的编号不需要在经过preprae确认，直接进⾏accept操作。此时该节点成为了leader，直到accept被拒绝，重新发起prepare请求竞争leader资格。 </p>
<h2 id="十一、简述raft算法"><a href="#十一、简述raft算法" class="headerlink" title="十一、简述raft算法"></a>十一、简述raft算法</h2><p>分布式⼀致性算法：raft会先选举出leader，leader完全负责replicatedlog的管理。leader负责接受所有 客户端更新请求，然后复制到follower节点，并在“安全”的时候执⾏这些请求。如果leader 故障， followes会重新选举出新的leader </p>
<p>三种状态：⼀个节点任⼀时刻处于三者之⼀ </p>
<p>leader：处理所有的客户端请求（如果客户端将请求发给了Follower，Follower将请求重定 向给 Leader） </p>
<p>follower：不会发送任何请求，只会简单地响应来⾃Leader或Candidate的请求 </p>
<p>candidate：⽤于选举产⽣新的leader(候选⼈) </p>
<p>term：任期，leader产⽣到重新选举为⼀任期，每个节点都维持着当前的任期号 </p>
<p>term是递增的，存储在log⽇志的entry中，代表当前entry是在哪⼀个term时期写⼊ 每个任期只能有⼀ 个leader或者没有(选举失败) </p>
<p>每次rpc通信时传递该任期号，如果RPC收到任期号⼤于本地的、切换为follower，⼩于本地 任期号 则返回错误信息 </p>
<p>两个RPC通信： </p>
<p>RequestVote RPC：负责选举，包含参数lastIndex，lastTerm AppendEntries RPC：负责数据的交 </p>
<p>互。</p>
<p>⽇志序列：每⼀个节点上维持着⼀份持久化Log，通过⼀致性协议算法，保证每⼀个节点中的Log 保持 ⼀致，并且顺序存放，这样客户端就可以在每⼀个节点中读取到相同的数据 </p>
<p>状态机：⽇志序列同步到多数节点时，leader将该⽇志提交到状态机，并在下⼀次⼼跳通知所有节点提 交状态机（携带最后提交的lastIndex） </p>
<p>何时触发选举： </p>
<p>集群初始化时，都是follower，随机超时，变成candidate，发起选举 如果follower在<em>election timeout</em>内没有收到来⾃leader的⼼跳，则主动触发选举 </p>
<p>选举过程：发出选举的节点⻆度 </p>
<p>1、增加节点本地的term，切换到candidate状态2、投⾃⼰⼀票 其他节点投票逻辑：每个节点同⼀任期最多只能投⼀票，候选⼈知道的信息不能⽐⾃⼰少（通过副 本⽇志和 安全机制保障），先来先得 </p>
<p>3、并⾏给其他节点发送<em>RequestVote RPCs</em>(选举请求)、包含term参数 </p>
<p>4、等待回复 </p>
<p>4.1、收到majority(⼤多数)的投票，赢得选举，切换到leader状态，⽴刻给所有节点发⼼跳消息 4.2、 被告知别⼈当选，切换到follower状态。（原来的leader对⽐term，⽐⾃⼰的⼤，转换到 follower状态） </p>
<p>4.3、⼀段时间没收到majority和leader的⼼跳通知，则保持candidate、重新发出选举⽇志序列同步：⽇志需要存储在磁盘持久化，崩溃可以从⽇志恢复 </p>
<p>1、客户端发送命令给Leader。 </p>
<p>2、Leader把⽇志条⽬加到⾃⼰的⽇志序列⾥。 </p>
<p>3、Leader发送AppendEntriesRPC请求给所有的follower。携带了prevLogIndex，prevLogTerm follower收到后，进⾏⽇志序列匹配 </p>
<p>匹配上则追加到⾃⼰的⽇志序列 </p>
<p>匹配不上则拒绝请求，leader将⽇志index调⼩，重新同步直⾄匹配上，follower将leader的⽇志 序列 覆盖到本地 </p>
<p>⼀旦新的⽇志序列条⽬变成majority的了，将⽇志序列应⽤到状态机中Leader在状态机⾥提交⾃⼰⽇志序列条⽬，然后返回结果给客户端 Leader下次发送AppendEntriesRPC时，告知follower已经提交的⽇志序列条⽬信息(lastIndex) follower收到RPC后，提交到⾃⼰的状态机⾥ 提交状态机时，如果term为上⼀任期，必须与当前任期数据⼀起提交，否则可能出现覆盖已提交状态机的⽇志 </p>
<p>新选举出的leader⼀定拥有所有已提交状态机的⽇志条⽬ leader在当⽇志序列条⽬已经复制到⼤多数follower机器上时，才会提交⽇志条⽬。 ⽽选出的leader的logIndex必须⼤于等于⼤多数节点，因此leader肯定有最新的⽇志 </p>
<p>安全原则： </p>
<p>选举安全原则：对于⼀个给定的任期号，最多只会有⼀个领导⼈被选举出来 </p>
<p>状态机安全原则：如果⼀个leader已经在给定的索引值位置的⽇志条⽬应⽤到状态机中，那么其他任何 的服务器在这个索引位置不会提交⼀个不同的⽇志 </p>
<p>领导⼈完全原则：如果某个⽇志条⽬在某个任期号中已经被提交，那么这个条⽬必然出现在更⼤任 期 号的所有领导⼈中 </p>
<p>领导⼈只附加原则：领导⼈绝对不会删除或者覆盖⾃⼰的⽇志，只会增加 ⽇志匹配原则：如果两个⽇志在相同的索引位置的⽇志条⽬的任期号相同，那么我们就认为这个⽇ 志 从头到这个索引位置之间全部完全相同 </p>
<h2 id="十二、Zookeeper相关"><a href="#十二、Zookeeper相关" class="headerlink" title="十二、Zookeeper相关"></a>十二、Zookeeper相关</h2><h3 id="1、为什么Zookeeper可以⽤来作为注册中⼼"><a href="#1、为什么Zookeeper可以⽤来作为注册中⼼" class="headerlink" title="1、为什么Zookeeper可以⽤来作为注册中⼼"></a>1、为什么Zookeeper可以⽤来作为注册中⼼</h3><p>可以利⽤Zookeeper的临时节点和watch机制来实现注册中⼼的⾃动注册和发现，另外Zookeeper中的 数据都是存在内存中的，并且Zookeeper底层采⽤了nio，多线程模型，所以Zookeeper的性能也是⽐较⾼的，所以可以⽤来作为注册中⼼，但是如果考虑到注册中⼼应该是注册可⽤性的话，那么Zookeeper 则不太合适，因为Zookeeper是CP的，它注重的是⼀致性，所以集群数据不⼀致时，集群将不可⽤，所以⽤Redis、Eureka、Nacos来作为注册中⼼将更合适</p>
<h3 id="2、Zookeeper中的领导者选举的流程是怎样的？"><a href="#2、Zookeeper中的领导者选举的流程是怎样的？" class="headerlink" title="2、Zookeeper中的领导者选举的流程是怎样的？"></a>2、Zookeeper中的领导者选举的流程是怎样的？</h3><p>对于Zookeeper集群，整个集群需要从集群节点中选出⼀个节点作为Leader，⼤体流程如下： </p>
<ol>
<li><p>集群中各个节点⾸先都是观望状态（LOOKING），⼀开始都会投票给⾃⼰，认为⾃⼰⽐较适合作 为leader </p>
</li>
<li><p>然后相互交互投票，每个节点会收到其他节点发过来的选票，然后pk，先⽐较zxid，zxid⼤者获 胜，zxid如果相等则⽐较myid，myid⼤者获胜 </p>
</li>
<li><p>⼀个节点收到其他节点发过来的选票，经过PK后，如果PK输了，则改票，此节点就会投给zxid或 myid更⼤的节点，并将选票放⼊⾃⼰的投票箱中，并将新的选票发送给其他节点 </p>
</li>
<li><p>如果pk是平局则将接收到的选票放⼊⾃⼰的投票箱中 </p>
</li>
<li><p>如果pk赢了，则忽略所接收到的选票 </p>
</li>
<li><p>当然⼀个节点将⼀张选票放⼊到⾃⼰的投票箱之后，就会从投票箱中统计票数，看是否超过⼀半的 节点都和⾃⼰所投的节点是⼀样的，如果超过半数，那么则认为当前⾃⼰所投的节点是leader </p>
</li>
<li><p>集群中每个节点都会经过同样的流程，pk的规则也是⼀样的，⼀旦改票就会告诉给其他服务器，所 以最终各个节点中的投票箱中的选票也将是⼀样的，所以各个节点最终选出来的leader也是⼀样的，这样集群的leader就选举出来了</p>
</li>
</ol>
<h3 id="3、Zookeeper集群中节点之间数据是如何同步的"><a href="#3、Zookeeper集群中节点之间数据是如何同步的" class="headerlink" title="3、Zookeeper集群中节点之间数据是如何同步的"></a>3、Zookeeper集群中节点之间数据是如何同步的</h3><ol>
<li><p>⾸先集群启动时，会先进⾏领导者选举，确定哪个节点是Leader，哪些节点是Follower和Observer </p>
</li>
<li><p>然后Leader会和其他节点进⾏数据同步，采⽤发送快照和发送Diff⽇志的⽅式 </p>
</li>
<li><p>集群在⼯作过程中，所有的写请求都会交给Leader节点来进⾏处理，从节点只能处理读请求 </p>
</li>
<li><p>Leader节点收到⼀个写请求时，会通过两阶段机制来处理 </p>
</li>
<li><p>Leader节点会将该写请求对应的⽇志发送给其他Follower节点，并等待Follower节点持久化⽇志成 功 </p>
</li>
<li><p>Follower节点收到⽇志后会进⾏持久化，如果持久化成功则发送⼀个Ack给Leader节点 </p>
</li>
<li><p>当Leader节点收到半数以上的Ack后，就会开始提交，先更新Leader节点本地的内存数据 </p>
</li>
<li><p>然后发送commit命令给Follower节点，Follower节点收到commit命令后就会更新各⾃本地内存数 据 </p>
</li>
<li><p>同时Leader节点还是将当前写请求直接发送给Observer节点，Observer节点收到Leader发过来的 写请求后直接执⾏更新本地内存数据 </p>
</li>
<li><p>最后Leader节点返回客户端写请求响应成功 </p>
</li>
<li><p>通过同步机制和两阶段提交机制来达到集群中节点数据⼀致</p>
</li>
</ol>
<h3 id="4、Zookeeper的数据模型和节点类型"><a href="#4、Zookeeper的数据模型和节点类型" class="headerlink" title="4、Zookeeper的数据模型和节点类型"></a>4、Zookeeper的数据模型和节点类型</h3><p>数据模型：树形结构 </p>
<p>zk维护的数据主要有：客户端的会话（session）状态及数据节点（dataNode）信息。 </p>
<p>zk在内存中构造了个DataTree的数据结构，维护着path到dataNode的映射以及dataNode间的树状层级 关系。为了提⾼读取性能，集群中每个服务节点都是将数据全量存储在内存中。所以，zk最适于读多写 少且轻量级数据的应⽤场景。 </p>
<p>数据仅存储在内存是很不安全的，zk采⽤事务⽇志⽂件及快照⽂件的⽅案来落盘数据，保障数据在不丢 失的情况下能快速恢复。 </p>
<p>树中的每个节点被称为— Znode </p>
<p>Znode 兼具⽂件和⽬录两种特点。可以做路径标识，也可以存储数据，并可以具有⼦ Znode。具有 增、删、改、查等操作。</p>
<p>Znode 具有原⼦性操作，读操作将获取与节点相关的所有数据，写操作也将 替换掉节点的所有数据。 另外，每⼀个节点都拥有⾃⼰的 ACL(访问控制列 表)，这个列表规定了⽤户的权限，即限定了特定⽤户 对⽬标节点可以执⾏的操作 </p>
<p>Znode 存储数据⼤⼩有限制。每个 Znode 的数据⼤⼩⾄多 1M，常规使⽤中应该远⼩于此值。 </p>
<p>Znode 通过路径引⽤，如同 Unix 中的⽂件路径。路径必须是绝对的，因此他们必须由斜杠字符来开 头。除此以外，他们必须是唯⼀的，也就是说每⼀个路径只有⼀个表示，因此这些路径不能改变。在 ZooKeeper 中，路径由 Unicode 字符串组成，并且有⼀些限制。字符串”/zookeeper”⽤以保存管理信 息，⽐如关键配额信息。 </p>
<p>持久节点：⼀旦创建、该数据节点会⼀直存储在zk服务器上、即使创建该节点的客户端与服务端的会话 关闭了、该节点也不会被删除 </p>
<p>临时节点：当创建该节点的客户端会话因超时或发⽣异常⽽关闭时、该节点也相应的在zk上被删除 。 </p>
<p>有序节点：不是⼀种单独种类的节点、⽽是在持久节点和临时节点的基础上、增加了⼀个节点有序的性质</p>
<h3 id="5、简述zk的命名服务、配置管理、集群管理"><a href="#5、简述zk的命名服务、配置管理、集群管理" class="headerlink" title="5、简述zk的命名服务、配置管理、集群管理"></a>5、简述zk的命名服务、配置管理、集群管理</h3><p>命名服务： </p>
<p>通过指定的名字来获取资源或者服务地址。Zookeeper可以创建⼀个全局唯⼀的路径，这个路径就可以 作为⼀个名字。被命名的实体可以是集群中的机器，服务的地址，或者是远程的对象等。⼀些分布式服 务框架（RPC、RMI）中的服务地址列表，通过使⽤命名服务，客户端应⽤能够根据特定的名字来获取 资源的实体、服务地址和提供者信息等 </p>
<p>配置管理： </p>
<p>实际项⽬开发中，经常使⽤.properties或者xml需要配置很多信息，如数据库连接信息、fps地址端⼝等 等。程序分布式部署时，如果把程序的这些配置信息保存在zk的znode节点下，当你要修改配置，即 znode会发⽣变化时，可以通过改变zk中某个⽬录节点的内容，利⽤watcher通知给各个客户端，从⽽ 更改配置。 </p>
<p>集群管理： </p>
<p>集群管理包括集群监控和集群控制，就是监控集群机器状态，剔除机器和加⼊机器。zookeeper可以⽅ 便集群机器的管理，它可以实时监控znode节点的变化，⼀旦发现有机器挂了，该机器就会与zk断开连 接，对应的临时⽬录节点会被删除，其他所有机器都收到通知。新机器加⼊也是类似。 </p>
<h3 id="6、讲下Zookeeper中的watch机制"><a href="#6、讲下Zookeeper中的watch机制" class="headerlink" title="6、讲下Zookeeper中的watch机制"></a>6、讲下Zookeeper中的watch机制</h3><p>客户端，可以通过在znode上设置watch，实现实时监听znode的变化 </p>
<p>Watch事件是⼀个⼀次性的触发器，当被设置了Watch的数据发⽣了改变的时候，则服务器将这个改变 发送给设置了Watch的客户端 </p>
<ul>
<li>⽗节点的创建，修改，删除都会触发Watcher事件。 </li>
<li>⼦节点的创建，删除会触发Watcher事件。</li>
</ul>
<p>⼀次性：⼀旦被触发就会移除，再次使⽤需要重新注册，因为每次变动都需要通知所有客户端，⼀次性 可以减轻压⼒，3.6.0默认持久递归，可以触发多次 </p>
<p>轻量：只通知发⽣了事件，不会告知事件内容，减轻服务器和带宽压⼒ </p>
<p>Watcher 机制包括三个⻆⾊：客户端线程、客户端的 WatchManager 以及 ZooKeeper 服务器 </p>
<ol>
<li><p>客户端向 ZooKeeper 服务器注册⼀个 Watcher 监听， </p>
</li>
<li><p>把这个监听信息存储到客户端的 WatchManager 中 </p>
</li>
<li><p>当 ZooKeeper 中的节点发⽣变化时，会通知客户端，客户端会调⽤相应 Watcher 对象中的回调 ⽅法。watch回调是串⾏同步的</p>
</li>
</ol>
<h3 id="7、Zookeeper和Eureka的区别"><a href="#7、Zookeeper和Eureka的区别" class="headerlink" title="7、Zookeeper和Eureka的区别"></a>7、Zookeeper和Eureka的区别</h3><p>zk：CP设计(强⼀致性)，⽬标是⼀个分布式的协调系统，⽤于进⾏资源的统⼀管理。 当节点crash后，需要进⾏leader的选举，在这个期间内，zk服务是不可⽤的。</p>
<p>eureka：AP设计（⾼可⽤），⽬标是⼀个服务注册发现系统，专⻔⽤于微服务的服务发现注册。 </p>
<p>Eureka各个节点都是平等的，⼏个节点挂掉不会影响正常节点的⼯作，剩余的节点依然可以提供注册和 查询服务。⽽Eureka的客户端在向某个Eureka注册时如果发现连接失败，会⾃动切换⾄其他节点，只要 有⼀台Eureka还在，就能保证注册服务可⽤（保证可⽤性），只不过查到的信息可能不是最新的（不保 证强⼀致性） </p>
<p>同时当eureka的服务端发现85%以上的服务都没有⼼跳的话，它就会认为⾃⼰的⽹络出了问题，就不会 从服务列表中删除这些失去⼼跳的服务，同时eureka的客户端也会缓存服务信息。eureka对于服务注册 发现来说是⾮常好的选择。 </p>
<h2 id="十三、Dubbo相关"><a href="#十三、Dubbo相关" class="headerlink" title="十三、Dubbo相关"></a>十三、Dubbo相关</h2><h3 id="1、Dubbo⽀持哪些负载均衡策略"><a href="#1、Dubbo⽀持哪些负载均衡策略" class="headerlink" title="1、Dubbo⽀持哪些负载均衡策略"></a>1、Dubbo⽀持哪些负载均衡策略</h3><ol>
<li><p>随机：从多个服务提供者随机选择⼀个来处理本次请求，调⽤量越⼤则分布越均匀，并⽀持按权重 设置随机概率 </p>
</li>
<li><p>轮询：依次选择服务提供者来处理请求， 并⽀持按权重进⾏轮询，底层采⽤的是平滑加权轮询算法 </p>
</li>
<li><p>最⼩活跃调⽤数：统计服务提供者当前正在处理的请求，下次请求过来则交给活跃数最⼩的服务器 来处理 </p>
</li>
<li><p>⼀致性哈希：相同参数的请求总是发到同⼀个服务提供者</p>
</li>
</ol>
<h3 id="2、Dubbo是如何完成服务导出的？"><a href="#2、Dubbo是如何完成服务导出的？" class="headerlink" title="2、Dubbo是如何完成服务导出的？"></a>2、Dubbo是如何完成服务导出的？</h3><ol>
<li><p>⾸先Dubbo会将程序员所使⽤的@DubboService注解或@Service注解进⾏解析得到程序员所定义 的服务参数，包括定义的服务名、服务接⼝、服务超时时间、服务协议等等，得到⼀个ServiceBean。 </p>
</li>
<li><p>然后调⽤ServiceBean的export⽅法进⾏服务导出 </p>
</li>
<li><p>然后将服务信息注册到注册中⼼，如果有多个协议，多个注册中⼼，那就将服务按单个协议，单个 注册中⼼进⾏注册 </p>
</li>
<li><p>将服务信息注册到注册中⼼后，还会绑定⼀些监听器，监听动态配置中⼼的变更 </p>
</li>
<li><p>还会根据服务协议启动对应的Web服务器或⽹络框架，⽐如Tomcat、Netty等</p>
</li>
</ol>
<h3 id="3、Dubbo是如何完成服务引⼊的？"><a href="#3、Dubbo是如何完成服务引⼊的？" class="headerlink" title="3、Dubbo是如何完成服务引⼊的？"></a>3、Dubbo是如何完成服务引⼊的？</h3><ol>
<li><p>当程序员使⽤@Reference注解来引⼊⼀个服务时，Dubbo会将注解和服务的信息解析出来，得到 当前所引⽤的服务名、服务接⼝是什么 </p>
</li>
<li><p>然后从注册中⼼进⾏查询服务信息，得到服务的提供者信息，并存在消费端的服务⽬录中 </p>
</li>
<li><p>并绑定⼀些监听器⽤来监听动态配置中⼼的变更 </p>
</li>
<li><p>然后根据查询得到的服务提供者信息⽣成⼀个服务接⼝的代理对象，并放⼊Spring容器中作为Bean</p>
</li>
</ol>
<h3 id="4、Dubbo的架构设计是怎样的？"><a href="#4、Dubbo的架构设计是怎样的？" class="headerlink" title="4、Dubbo的架构设计是怎样的？"></a>4、Dubbo的架构设计是怎样的？</h3><p>Dubbo中的架构设计是⾮常优秀的，分为了很多层次，并且每层都是可以扩展的，⽐如： </p>
<ol>
<li><p>Proxy服务代理层，⽀持JDK动态代理、javassist等代理机制</p>
</li>
<li><p>Registry注册中⼼层，⽀持Zookeeper、Redis等作为注册中⼼ </p>
</li>
<li><p>Protocol远程调⽤层，⽀持Dubbo、Http等调⽤协议 </p>
</li>
<li><p>Transport⽹络传输层，⽀持netty、mina等⽹络传输框架 </p>
</li>
<li><p>Serialize数据序列化层，⽀持JSON、Hessian等序列化机制</p>
</li>
</ol>
<p>各层说明 </p>
<ul>
<li><p>config 配置层：对外配置接⼝，以 ServiceConfig , ReferenceConfig 为中⼼，可以直接 初始化配置类，也可以通过 spring 解析配置⽣成配置类 </p>
</li>
<li><p>proxy 服务代理层：服务接⼝透明代理，⽣成服务的客户端 Stub 和服务器端 Skeleton, 以 ServiceProxy 为中⼼，扩展接⼝为 ProxyFactory </p>
</li>
<li><p>registry 注册中⼼层：封装服务地址的注册与发现，以服务 URL 为中⼼，扩展接⼝为 RegistryFactory , Registry , RegistryService </p>
</li>
<li><p>cluster 路由层：封装多个提供者的路由及负载均衡，并桥接注册中⼼，以 Invoker 为中⼼，扩 展接⼝为 Cluster , Directory , Router , LoadBalance </p>
</li>
<li><p>monitor 监控层：RPC 调⽤次数和调⽤时间监控，以 Statistics 为中⼼，扩展接⼝为 MonitorFactory , Monitor , MonitorService </p>
</li>
<li><p>protocol 远程调⽤层：封装 RPC 调⽤，以 Invocation , Result 为中⼼，扩展接⼝为 Protocol , Invoker , Exporter </p>
</li>
<li><p>exchange 信息交换层：封装请求响应模式，同步转异步，以 Request , Response 为中⼼，扩 展接⼝为 Exchanger , ExchangeChannel , ExchangeClient , ExchangeServer </p>
</li>
<li><p>transport ⽹络传输层：抽象 mina 和 netty 为统⼀接⼝，以 Message 为中⼼，扩展接⼝为 Channel , Transporter , Client , Server , Codec </p>
</li>
<li><p>serialize 数据序列化层：可复⽤的⼀些⼯具，扩展接⼝为 Serialization , ObjectInput , ObjectOutput , ThreadPool</p>
</li>
</ul>
<p>关系说明 </p>
<ul>
<li><p>在 RPC 中，Protocol 是核⼼层，也就是只要有 Protocol + Invoker + Exporter 就可以完成⾮透明 的 RPC 调⽤，然后在 Invoker 的主过程上 Filter 拦截点。 </p>
</li>
<li><p>图中的 Consumer 和 Provider 是抽象概念，只是想让看图者更直观的了解哪些类分属于客户端与 服务器端，不⽤ Client 和 Server 的原因是 Dubbo 在很多场景下都使⽤ Provider, Consumer, Registry, Monitor 划分逻辑拓普节点，保持统⼀概念。 </p>
</li>
<li><p>⽽ Cluster 是外围概念，所以 Cluster 的⽬的是将多个 Invoker 伪装成⼀个 Invoker，这样其它⼈ 只要关注 Protocol 层 Invoker 即可，加上 Cluster 或者去掉 Cluster 对其它层都不会造成影响，因为只有⼀个提供者时，是不需要 Cluster 的。 </p>
</li>
<li><p>Proxy 层封装了所有接⼝的透明化代理，⽽在其它层都以 Invoker 为中⼼，只有到了暴露给⽤户使 ⽤时，才⽤ Proxy 将 Invoker 转成接⼝，或将接⼝实现转成 Invoker，也就是去掉 Proxy 层 RPC 是可以 Run 的，只是不那么透明，不那么看起来像调本地服务⼀样调远程服务。</p>
</li>
<li><p>⽽ Remoting 实现是 Dubbo 协议的实现，如果你选择 RMI 协议，整个 Remoting 都不会⽤上， Remoting 内部再划为 Transport 传输层和 Exchange 信息交换层，Transport 层只负责单向消息 传输，是对 Mina, Netty, Grizzly 的抽象，它也可以扩展 UDP 传输，⽽ Exchange 层是在传输层 之上封装了 Request-Response 语义。 </p>
</li>
<li><p>Registry 和 Monitor 实际上不算⼀层，⽽是⼀个独⽴的节点，只是为了全局概览，⽤层的⽅式画在 ⼀起</p>
</li>
</ul>
<p><img src="https://notes-hub.oss-cn-beijing.aliyuncs.com/typora_images/image-20220810214308238.png" alt="image-20220810214308238"></p>
<h3 id="5、Spring-Cloud和Dubbo有哪些区别？"><a href="#5、Spring-Cloud和Dubbo有哪些区别？" class="headerlink" title="5、Spring Cloud和Dubbo有哪些区别？"></a>5、Spring Cloud和Dubbo有哪些区别？</h3><p>Spring Cloud是⼀个微服务框架，提供了微服务领域中的很多功能组件，Dubbo⼀开始是⼀个RPC调⽤ 框架，核⼼是解决服务调⽤间的问题，Spring Cloud是⼀个⼤⽽全的框架，Dubbo则更侧重于服务调 ⽤，所以Dubbo所提供的功能没有Spring Cloud全⾯，但是Dubbo的服务调⽤性能⽐Spring Cloud⾼， 不过Spring Cloud和Dubbo并不是对⽴的，是可以结合起来⼀起使⽤的</p>
<h2 id="十四、负载均衡算法有哪些"><a href="#十四、负载均衡算法有哪些" class="headerlink" title="十四、负载均衡算法有哪些"></a>十四、负载均衡算法有哪些</h2><p>1、轮询法：将请求按顺序轮流地分配到后端服务器上，它均衡地对待后端的每⼀台服务器，⽽不关⼼服 务器实际的连接数和当前的系统负载。 </p>
<p>2、随机法：通过系统的随机算法，根据后端服务器的列表⼤⼩值来随机选取其中的⼀台服务器进⾏访 问。由概率统计理论可以得知，随着客户端调⽤服务端的次数增多，其实际效果越来越接近于平均分配调⽤量到后端的每⼀台服务器，也就是轮询的结果。 </p>
<p>3、源地址哈希法：源地址哈希的思想是根据获取客户端的IP地址，通过哈希函数计算得到的⼀个数值， ⽤该数值对服务器列表的⼤⼩进⾏取模运算，得到的结果便是客服端要访问服务器的序号。采⽤源地址 哈希法进⾏负载均衡，同⼀IP地址的客户端，当后端服务器列表不变时，它每次都会映射到同⼀台后端服务器进⾏访问。 </p>
<p>4、加权轮询法：不同的后端服务器可能机器的配置和当前系统的负载并不相同，因此它们的抗压能⼒ 也不相同。给配置⾼、负载低的机器配置更⾼的权重，让其处理更多的请；⽽配置低、负载⾼的机器，给其分配较低的权重，降低其系统负载，加权轮询能很好地处理这⼀问题，并将请求顺序且按照权重分配到后端。 </p>
<p>5、加权随机法：与加权轮询法⼀样，加权随机法也根据后端机器的配置，系统的负载分配不同的权重。不同的是，它是按照权重随机请求后端服务器，⽽⾮顺序。 </p>
<p>6、最⼩连接数法：最⼩连接数算法⽐较灵活和智能，由于后端服务器的配置不尽相同，对于请求的处理有快有慢，它是根据后端服务器当前的连接情况，动态地选取其中当前积压连接数最少的⼀台服务器来处理当前的请求，尽可能地提⾼后端服务的利⽤效率，将负责合理地分流到每⼀台服务器</p>
<h2 id="十五、分布式架构下，Session-共享有什么⽅案"><a href="#十五、分布式架构下，Session-共享有什么⽅案" class="headerlink" title="十五、分布式架构下，Session 共享有什么⽅案"></a>十五、分布式架构下，Session 共享有什么⽅案</h2><p>1、采⽤⽆状态服务，抛弃session </p>
<p>2、存⼊cookie（有安全⻛险） </p>
<p>3、服务器之间进⾏ Session 同步，这样可以保证每个服务器上都有全部的 Session 信息，不过当服务 器数量⽐较多的时候，同步是会有延迟甚⾄同步失败； </p>
<p>4、 IP 绑定策略 </p>
<p>使⽤ Nginx （或其他复杂均衡软硬件）中的 IP 绑定策略，同⼀个 IP 只能在指定的同⼀个机器访问，但 是这样做失去了负载均衡的意义，当挂掉⼀台服务器的时候，会影响⼀批⽤户的使⽤，⻛险很⼤； </p>
<p>5、使⽤ Redis 存储</p>
<p>把 Session 放到 Redis 中存储，虽然架构上变得复杂，并且需要多访问⼀次 Redis ，但是这种⽅案带 来的好处也是很⼤的： </p>
<ul>
<li>实现了 Session 共享； </li>
<li>可以⽔平扩展（增加 Redis 服务器）； </li>
<li>服务器重启 Session 不丢失（不过也要注意 Session 在 Redis 中的刷新/失效机制）； </li>
<li>不仅可以跨服务器 Session 共享，甚⾄可以跨平台（例如⽹⻚端和 APP 端）。</li>
</ul>
<h2 id="十六、简述你对RPC、RMI的理解"><a href="#十六、简述你对RPC、RMI的理解" class="headerlink" title="十六、简述你对RPC、RMI的理解"></a>十六、简述你对RPC、RMI的理解</h2><p>RPC：在本地调⽤远程的函数，远程过程调⽤，可以跨语⾔实现 httpClient </p>
<p>RMI：远程⽅法调⽤，java中⽤于实现RPC的⼀种机制，RPC的java版本，是J2EE的⽹络调⽤机制，跨JVM调⽤对象的⽅法，⾯向对象的思维⽅式 </p>
<p>直接或间接实现接⼝ java.rmi.Remote 成为存在于服务器端的远程对象，供客户端访问并提供⼀定的 </p>
<p>服务</p>
<p>远程对象必须实现java.rmi.server.UniCastRemoteObject类，这样才能保证客户端访问获得远程对象 时，该远程对象将会把⾃身的⼀个拷⻉以Socket的形式传输给客户端，此时客户端所获得的这个拷⻉称 为“存根”，⽽服务器端本身已存在的远程对象则称之为“⻣架”。其实此时的存根是客户端的⼀个代理， ⽤于与服务器端的通信，⽽⻣架也可认为是服务器端的⼀个代理，⽤于接收客户端的请求之后调⽤远程 ⽅法来响应客户端的请求。</p>
<pre class=" language-java"><code class="language-java">
<span class="token keyword">public</span> <span class="token keyword">interface</span> <span class="token class-name">IService</span> <span class="token keyword">extends</span> <span class="token class-name">Remote</span> <span class="token punctuation">{</span>
    String <span class="token function">service</span><span class="token punctuation">(</span>String content<span class="token punctuation">)</span> <span class="token keyword">throws</span> RemoteException<span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">class</span> <span class="token class-name">ServiceImpl</span> <span class="token keyword">extends</span> <span class="token class-name">UnicastRemoteObject</span> <span class="token keyword">implements</span> <span class="token class-name">IService</span> <span class="token punctuation">{</span>
    <span class="token keyword">private</span> String name<span class="token punctuation">;</span>

    <span class="token keyword">public</span> <span class="token function">ServiceImpl</span><span class="token punctuation">(</span>String name<span class="token punctuation">)</span> <span class="token keyword">throws</span> RemoteException <span class="token punctuation">{</span>
        <span class="token keyword">this</span><span class="token punctuation">.</span>name <span class="token operator">=</span> name<span class="token punctuation">;</span>
    <span class="token punctuation">}</span>

    <span class="token annotation punctuation">@Override</span>
    <span class="token keyword">public</span> String <span class="token function">service</span><span class="token punctuation">(</span>String content<span class="token punctuation">)</span> <span class="token punctuation">{</span>
        <span class="token keyword">return</span> <span class="token string">"server >> "</span> <span class="token operator">+</span> content<span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">class</span> <span class="token class-name">Server</span> <span class="token punctuation">{</span>
    <span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">void</span> <span class="token function">main</span><span class="token punctuation">(</span>String<span class="token punctuation">[</span><span class="token punctuation">]</span> args<span class="token punctuation">)</span> <span class="token punctuation">{</span>
        <span class="token keyword">try</span> <span class="token punctuation">{</span>
            IService service02 <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">ServiceImpl</span><span class="token punctuation">(</span><span class="token string">"service02"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            Context namingContext <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">InitialContext</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            namingContext<span class="token punctuation">.</span><span class="token function">rebind</span><span class="token punctuation">(</span><span class="token string">"rmi://127.0.0.1/service02"</span><span class="token punctuation">,</span> service02<span class="token punctuation">)</span><span class="token punctuation">;</span>
        <span class="token punctuation">}</span> <span class="token keyword">catch</span> <span class="token punctuation">(</span><span class="token class-name">Exception</span> e<span class="token punctuation">)</span> <span class="token punctuation">{</span>
            e<span class="token punctuation">.</span><span class="token function">printStackTrace</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
        <span class="token punctuation">}</span>
        System<span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"000000！"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
<span class="token punctuation">}</span>

<span class="token keyword">public</span> <span class="token keyword">class</span> <span class="token class-name">Client</span> <span class="token punctuation">{</span>
    <span class="token keyword">public</span> <span class="token keyword">static</span> <span class="token keyword">void</span> <span class="token function">main</span><span class="token punctuation">(</span>String<span class="token punctuation">[</span><span class="token punctuation">]</span> args<span class="token punctuation">)</span> <span class="token punctuation">{</span>
        String url <span class="token operator">=</span> <span class="token string">"rmi://127.0.0.1/"</span><span class="token punctuation">;</span>
        <span class="token keyword">try</span> <span class="token punctuation">{</span>
            Context namingContext <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">InitialContext</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            IService service02 <span class="token operator">=</span> <span class="token punctuation">(</span>IService<span class="token punctuation">)</span> namingContext<span class="token punctuation">.</span><span class="token function">lookup</span><span class="token punctuation">(</span>url <span class="token operator">+</span> <span class="token string">"service02"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            Class <span class="token class-name">stubClass</span> <span class="token operator">=</span> service02<span class="token punctuation">.</span><span class="token function">getClass</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            System<span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>service02 <span class="token operator">+</span> <span class="token string">" is "</span> <span class="token operator">+</span> stubClass<span class="token punctuation">.</span><span class="token function">getName</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            Class<span class="token punctuation">[</span><span class="token punctuation">]</span> interfaces <span class="token operator">=</span> stubClass<span class="token punctuation">.</span><span class="token function">getInterfaces</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            <span class="token keyword">for</span> <span class="token punctuation">(</span>Class <span class="token class-name">c</span> <span class="token operator">:</span> interfaces<span class="token punctuation">)</span> <span class="token punctuation">{</span>
                System<span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"implement"</span> <span class="token operator">+</span> c<span class="token punctuation">.</span><span class="token function">getName</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">+</span> <span class="token string">" interface"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            <span class="token punctuation">}</span>
            System<span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span>service02<span class="token punctuation">.</span><span class="token function">service</span><span class="token punctuation">(</span><span class="token string">"hello"</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
        <span class="token punctuation">}</span> <span class="token keyword">catch</span> <span class="token punctuation">(</span><span class="token class-name">Exception</span> e<span class="token punctuation">)</span> <span class="token punctuation">{</span>
            e<span class="token punctuation">.</span><span class="token function">printStackTrace</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
        <span class="token punctuation">}</span>
    <span class="token punctuation">}</span>
<span class="token punctuation">}</span> 
</code></pre>
<h2 id="十七、如何实现接⼝的幂等性"><a href="#十七、如何实现接⼝的幂等性" class="headerlink" title="十七、如何实现接⼝的幂等性"></a>十七、如何实现接⼝的幂等性</h2><ul>
<li><p>唯⼀id。每次操作，都根据操作和内容⽣成唯⼀的id，在执⾏之前先判断id是否存在，如果不存在 则执⾏后续操作，并且保存到数据库或者redis等。 </p>
</li>
<li><p>服务端提供发送token的接⼝，业务调⽤接⼝前先获取token,然后调⽤业务接⼝请求时，把token携 带过去,务器判断token是否存在redis中，存在表示第⼀次请求，可以继续执⾏业务，执⾏业务完成 后，最后需要把redis中的token删除 </p>
</li>
<li><p>建去重表。将业务中有唯⼀标识的字段保存到去重表，如果表中存在，则表示已经处理过了 </p>
</li>
<li><p>版本控制。增加版本号，当版本号符合时，才能更新数据 </p>
</li>
<li><p>状态控制。例如订单有状态已⽀付 未⽀付 ⽀付中 ⽀付失败，当处于未⽀付的时候才允许修改为⽀ 付中等</p>
</li>
</ul>
<h2 id="十八、如何实现分库分表"><a href="#十八、如何实现分库分表" class="headerlink" title="十八、如何实现分库分表"></a>十八、如何实现分库分表</h2><p>将原本存储于单个数据库上的数据拆分到多个数据库，把原来存储在单张数据表的数据拆分到多张数据 表中，实现数据切分，从⽽提升数据库操作性能。分库分表的实现可以分为两种⽅式：垂直切分和⽔平 切分。 </p>
<p>⽔平：将数据分散到多张表，涉及分区键， </p>
<p>分库：每个库结构⼀样，数据不⼀样，没有交集。库多了可以缓解io和cpu压⼒ </p>
<p>分表：每个表结构⼀样，数据不⼀样，没有交集。表数量减少可以提⾼sql执⾏效率、减轻cpu压⼒ </p>
<p>垂直：将字段拆分为多张表，需要⼀定的重构 </p>
<p>分库：每个库结构、数据都不⼀样，所有库的并集为全量数据 </p>
<p>分表：每个表结构、数据不⼀样，⾄少有⼀列交集，⽤于关联数据，所有表的并集为全量数据 </p>
<h2 id="十九、存储拆分后如何解决唯⼀主键问题"><a href="#十九、存储拆分后如何解决唯⼀主键问题" class="headerlink" title="十九、存储拆分后如何解决唯⼀主键问题"></a>十九、存储拆分后如何解决唯⼀主键问题</h2><ul>
<li><p>UUID：简单、性能好，没有顺序，没有业务含义，存在泄漏mac地址的⻛险 </p>
</li>
<li><p>数据库主键：实现简单，单调递增，具有⼀定的业务可读性，强依赖db、存在性能瓶颈，存在暴露 业务 信息的⻛险 </p>
</li>
<li><p>redis，mongodb，zk等中间件：增加了系统的复杂度和稳定性 </p>
</li>
<li><p>雪花算法</p>
</li>
</ul>
<h2 id="二十、雪花算法原理"><a href="#二十、雪花算法原理" class="headerlink" title="二十、雪花算法原理"></a>二十、雪花算法原理</h2><p><img src="https://notes-hub.oss-cn-beijing.aliyuncs.com/typora_images/image-20220810220020139.png" alt="image-20220810220020139"></p>
<p>第⼀位符号位固定为0，41位时间戳，10位workId，12位序列号，位数可以有不同实现。 </p>
<p>优点：每个毫秒值包含的ID值很多，不够可以变动位数来增加，性能佳（依赖workId的实现）。时间戳 值在⾼位，中间是固定的机器码，⾃增的序列在低位，整个ID是趋势递增的。能够根据业务场景数据库 节点布置灵活调整bit位划分，灵活度⾼。 </p>
<p>缺点：强依赖于机器时钟，如果时钟回拨，会导致重复的ID⽣成，所以⼀般基于此的算法发现时钟回 拨，都会抛异常处理，阻⽌ID⽣成，这可能导致服务不可⽤</p>
<h2 id="二十一、如何解决不使⽤分区键的查询问题"><a href="#二十一、如何解决不使⽤分区键的查询问题" class="headerlink" title="二十一、如何解决不使⽤分区键的查询问题"></a>二十一、如何解决不使⽤分区键的查询问题</h2><ul>
<li><p>映射：将查询条件的字段与分区键进⾏映射，建⼀张单独的表维护(使⽤覆盖索引)或者在缓存中维 护 </p>
</li>
<li><p>基因法：分区键的后x个bit位由查询字段进⾏hash后占⽤，分区键直接取x个bit位获取分区，查询 字段进⾏hash获取分区，适合⾮分区键查询字段只有⼀个的情况 </p>
</li>
<li><p>冗余：查询字段冗余存储</p>
</li>
</ul>
<h2 id="二十二、Spring-Cloud有哪些常⽤组件，作⽤是什么？"><a href="#二十二、Spring-Cloud有哪些常⽤组件，作⽤是什么？" class="headerlink" title="二十二、Spring Cloud有哪些常⽤组件，作⽤是什么？"></a>二十二、Spring Cloud有哪些常⽤组件，作⽤是什么？</h2><ol>
<li><p>Eureka：注册中⼼ </p>
</li>
<li><p>Nacos：注册中⼼、配置中⼼ </p>
</li>
<li><p>Consul：注册中⼼、配置中⼼ </p>
</li>
<li><p>Spring Cloud Config：配置中⼼ </p>
</li>
<li><p>Feign/OpenFeign：RPC调⽤ </p>
</li>
<li><p>Kong：服务⽹关</p>
</li>
<li><p>Zuul：服务⽹关 </p>
</li>
<li><p>Spring Cloud Gateway：服务⽹关 </p>
</li>
<li><p>Ribbon：负载均衡 </p>
</li>
<li><p>Spring CLoud Sleuth：链路追踪 </p>
</li>
<li><p>Zipkin：链路追踪 </p>
</li>
<li><p>Seata：分布式事务 </p>
</li>
<li><p>Dubbo：RPC调⽤ </p>
</li>
<li><p>Sentinel：服务熔断 </p>
</li>
<li><p>Hystrix：服务熔断</p>
</li>
</ol>
<h2 id="二十三、缓存相关"><a href="#二十三、缓存相关" class="headerlink" title="二十三、缓存相关"></a>二十三、缓存相关</h2><h3 id="1、如何避免缓存穿透、缓存击穿、缓存雪崩？"><a href="#1、如何避免缓存穿透、缓存击穿、缓存雪崩？" class="headerlink" title="1、如何避免缓存穿透、缓存击穿、缓存雪崩？"></a>1、如何避免缓存穿透、缓存击穿、缓存雪崩？</h3><p>缓存雪崩是指缓存同⼀时间⼤⾯积的失效，所以，后⾯的请求都会落到数据库上，造成数据库短时间内 承受⼤量请求⽽崩掉。 </p>
<p>解决⽅案： </p>
<ul>
<li>缓存数据的过期时间设置随机，防⽌同⼀时间⼤量数据过期现象发⽣。 </li>
<li>给每⼀个缓存数据增加相应的缓存标记，记录缓存是否失效，如果缓存标记失效，则更新数据缓 存。 </li>
<li>缓存预热互斥锁</li>
</ul>
<p>缓存穿透是指缓存和数据库中都没有的数据，导致所有的请求都落到数据库上，造成数据库短时间内承 受⼤量请求⽽崩掉。 </p>
<p>解决⽅案： </p>
<ul>
<li><p>接⼝层增加校验，如⽤户鉴权校验，id做基础校验，id&lt;=0的直接拦截； </p>
</li>
<li><p>从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有 效时间可以设置短点，如30秒（设置太⻓会导致正常情况也没法使⽤）。这样可以防⽌攻击⽤户 反复⽤同⼀个id暴⼒攻击 </p>
</li>
<li><p>采⽤布隆过滤器，将所有可能存在的数据哈希到⼀个⾜够⼤的 bitmap 中，⼀个⼀定不存在的数据 会被这个 bitmap 拦截掉，从⽽避免了对底层存储系统的查询压⼒</p>
</li>
</ul>
<p>缓存击穿是指缓存中没有但数据库中有的数据（⼀般是缓存时间到期），这时由于并发⽤户特别多，同 时读缓存没读到数据，⼜同时去数据库去取数据，引起数据库压⼒瞬间增⼤，造成过⼤压⼒。和缓存雪 崩不同的是，缓存击穿指并发查同⼀条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从⽽查 数据库。 </p>
<p>解决⽅案： </p>
<ul>
<li>设置热点数据永远不过期。加互斥锁</li>
</ul>
<h3 id="2、分布式系统中常⽤的缓存⽅案有哪些"><a href="#2、分布式系统中常⽤的缓存⽅案有哪些" class="headerlink" title="2、分布式系统中常⽤的缓存⽅案有哪些"></a>2、分布式系统中常⽤的缓存⽅案有哪些</h3><ul>
<li><p>客户端缓存：⻚⾯和浏览器缓存，APP缓存，H5缓存，localStorage 和 sessionStorage CDN缓 存：内容存储：数据的缓存，内容分发：负载均衡 </p>
</li>
<li><p>nginx缓存：静态资源 </p>
</li>
<li><p>服务端缓存：本地缓存，外部缓存 </p>
</li>
<li><p>数据库缓存：持久层缓存（mybatis，hibernate多级缓存），mysql查询缓存 操作系统缓存： PageCache、BufferCache</p>
</li>
</ul>
<h3 id="3、缓存过期都有哪些策略？"><a href="#3、缓存过期都有哪些策略？" class="headerlink" title="3、缓存过期都有哪些策略？"></a>3、缓存过期都有哪些策略？</h3><p>定时过期：每个设置过期时间的key都需要创建⼀个定时器，到过期时间就会⽴即清除。该策略可 以⽴ 即清除过期的数据，对内存很友好；但是会占⽤⼤量的CPU资源去处理过期的数据，从⽽影响 缓存的响应时间和吞吐量 </p>
<p>惰性过期：只有当访问⼀个key时，才会判断该key是否已过期，过期则清除。该策略可以最⼤化地 节省CPU资源，但是很消耗内存、许多的过期数据都还存在内存中。极端情况可能出现⼤量的过期 key没有 再次被访问，从⽽不会被清除，占⽤⼤量内存。 </p>
<p>定期过期：每隔⼀定的时间，会扫描⼀定数量的数据库的expires字典中⼀定数量的key（是随机 的）， 并清除其中已过期的key。该策略是定时过期和惰性过期的折中⽅案。通过调整定时扫描的 时间间隔和 每次扫描的限定耗时，可以在不同情况下使得CPU和内存资源达到最优的平衡效果。 </p>
<p>分桶策略：定期过期的优化，将过期时间点相近的key放在⼀起，按时间扫描分桶。 </p>
<h3 id="4、常⻅的缓存淘汰算法"><a href="#4、常⻅的缓存淘汰算法" class="headerlink" title="4、常⻅的缓存淘汰算法"></a>4、常⻅的缓存淘汰算法</h3><ul>
<li><p>FIFO（First In First Out，先进先出），根据缓存被存储的时间，离当前最远的数据优先被淘汰； </p>
</li>
<li><p>LRU（LeastRecentlyUsed，最近最少使⽤），根据最近被使⽤的时间，离当前最远的数据优先被 淘汰； </p>
</li>
<li><p>LFU（LeastFrequentlyUsed，最不经常使⽤），在⼀段时间内，缓存数据被使⽤次数最少的会被 淘汰</p>
</li>
</ul>
<h3 id="5、分布式缓存寻址算法"><a href="#5、分布式缓存寻址算法" class="headerlink" title="5、分布式缓存寻址算法"></a>5、分布式缓存寻址算法</h3><ul>
<li><p>hash算法：根据key进⾏hash函数运算、结果对分⽚数取模，确定分⽚ 适合固定分⽚数的场景， 扩展分⽚或者减少分⽚时，所有数据都需要重新计算分⽚、存储 </p>
</li>
<li><p>⼀致性hash：将整个hash值得区间组织成⼀个闭合的圆环，计算每台服务器的hash值、映射到圆 环中。使⽤相同的hash算法计算数据的hash值，映射到圆环，顺时针寻找，找到的第⼀个服务器就 是数据存储的服务器。新增及减少节点时只会影响节点到他逆时针最近的⼀个服务器之间的值 存在 hash环倾斜的问题，即服务器分布不均匀，可以通过虚拟节点解决 </p>
</li>
<li><p>hash slot：将数据与服务器隔离开，数据与slot映射，slot与服务器映射，数据进⾏hash决定存放 的slot，新增及删除节点时，将slot进⾏迁移即可</p>
</li>
</ul>
<h2 id="二十四、布隆过滤器原理，优缺点"><a href="#二十四、布隆过滤器原理，优缺点" class="headerlink" title="二十四、布隆过滤器原理，优缺点"></a>二十四、布隆过滤器原理，优缺点</h2><ul>
<li><p>位图：int[10]，每个int类型的整数是4*8=32个bit，则int[10]⼀共有320 bit，每个bit⾮0即1，初始 化时都是0 </p>
</li>
<li><p>添加数据时：将数据进⾏hash得到hash值，对应到bit位，将该bit改为1，hash函数可以定义多个， 则 ⼀个数据添加会将多个（hash函数个数）bit改为1，多个hash函数的⽬的是减少hash碰撞的 概率</p>
</li>
<li><p>查询数据：hash函数计算得到hash值，对应到bit中，如果有⼀个为0，则说明数据不在bit中，如果 都为1，则该数据可能在bit中</p>
</li>
</ul>
<p>优点：</p>
<ul>
<li><p>占⽤内存⼩ </p>
</li>
<li><p>增加和查询元素的时间复杂度为：O(K), (K为哈希函数的个数，⼀般⽐较⼩)，与数据量⼤⼩⽆关哈 </p>
<p>希函数相互之间没有关系，⽅便硬件并⾏运算 </p>
</li>
<li><p>布隆过滤器不需要存储元素本身，在某些对保密要求⽐较严格的场合有很⼤优势 数据量很⼤时，布 </p>
<p>隆过滤器可以表示全集 </p>
</li>
<li><p>使⽤同⼀组散列函数的布隆过滤器可以进⾏交、并、差运算</p>
</li>
</ul>
<p>缺点：</p>
<ul>
<li>误判率，即存在假阳性(False Position)，不能准确判断元素是否在集合中不能获取元素本身 </li>
<li>⼀般情况下不能从布隆过滤器中删除元素</li>
</ul>
<h2 id="二十五、什么是Hystrix？简述实现机制"><a href="#二十五、什么是Hystrix？简述实现机制" class="headerlink" title="二十五、什么是Hystrix？简述实现机制"></a>二十五、什么是Hystrix？简述实现机制</h2><p>分布式容错框架 </p>
<ul>
<li>阻⽌故障的连锁反应，实现熔断 </li>
<li>快速失败，实现优雅降级 </li>
<li>提供实时的监控和告警</li>
</ul>
<p>资源隔离：线程隔离，信号量隔离 </p>
<ul>
<li><p>线程隔离：Hystrix会给每⼀个Command分配⼀个单独的线程池，这样在进⾏单个服务调⽤的时 候，就可以在独⽴的线程池⾥⾯进⾏，⽽不会对其他线程池造成影响 </p>
</li>
<li><p>信号量隔离：客户端需向依赖服务发起请求时，⾸先要获取⼀个信号量才能真正发起调⽤，由于信 号量的数量有限，当并发请求量超过信号量个数时，后续的请求都会直接拒绝，进⼊fallback流 程。信号量隔离主要是通过控制并发请求量，防⽌请求线程⼤⾯积阻塞，从⽽达到限流和防⽌雪崩的⽬的。</p>
</li>
</ul>
<p>熔断和降级：调⽤服务失败后快速失败 </p>
<p>熔断是为了防⽌异常不扩散，保证系统的稳定性 </p>
<p>降级：编写好调⽤失败的补救逻辑，然后对服务直接停⽌运⾏，这样这些接⼝就⽆法正常调⽤，但⼜不 ⾄于直接报错，只是服务⽔平下降 </p>
<ul>
<li><p>通过HystrixCommand 或者HystrixObservableCommand 将所有的外部系统（或者称为依赖）包 装起来，整个包装对象是单独运⾏在⼀个线程之中（这是典型的命令模式）。 </p>
</li>
<li><p>超时请求应该超过你定义的阈值 </p>
</li>
<li><p>为每个依赖关系维护⼀个⼩的线程池（或信号量）; 如果它变满了，那么依赖关系的请求将⽴即被 拒绝，⽽不是排队等待。 </p>
</li>
<li><p>统计成功，失败（由客户端抛出的异常），超时和线程拒绝。 </p>
</li>
<li><p>打开断路器可以在⼀段时间内停⽌对特定服务的所有请求，如果服务的错误百分⽐通过阈值，⼿动 或⾃动的关闭断路器。 </p>
</li>
<li><p>当请求被拒绝、连接超时或者断路器打开，直接执⾏fallback逻辑。 </p>
</li>
<li><p>近乎实时监控指标和配置变化。</p>
</li>
</ul>
<h2 id="二十六、什么是服务雪崩？什么是服务限流？"><a href="#二十六、什么是服务雪崩？什么是服务限流？" class="headerlink" title="二十六、什么是服务雪崩？什么是服务限流？"></a>二十六、什么是服务雪崩？什么是服务限流？</h2><ol>
<li><p>当服务A调⽤服务B，服务B调⽤C，此时⼤量请求突然请求服务A，假如服务A本身能抗住这些请 求，但是如果服务C抗不住，导致服务C请求堆积，从⽽服务B请求堆积，从⽽服务A不可⽤，这就 是服务雪崩，解决⽅式就是服务降级和服务熔断。 </p>
</li>
<li><p>服务限流是指在⾼并发请求下，为了保护系统，可以对访问服务的请求进⾏数量上的限制，从⽽防 ⽌系统不被⼤量请求压垮，在秒杀中，限流是⾮常重要的</p>
</li>
</ol>
<h2 id="二十七、什么是服务熔断？什么是服务降级？区别是什么？"><a href="#二十七、什么是服务熔断？什么是服务降级？区别是什么？" class="headerlink" title="二十七、什么是服务熔断？什么是服务降级？区别是什么？"></a>二十七、什么是服务熔断？什么是服务降级？区别是什么？</h2><ol>
<li><p>服务熔断是指，当服务A调⽤的某个服务B不可⽤时，上游服务A为了保证⾃⼰不受影响，从⽽不再 调⽤服务B，直接返回⼀个结果，减轻服务A和服务B的压⼒，直到服务B恢复。 </p>
</li>
<li><p>服务降级是指，当发现系统压⼒过载时，可以通过关闭某个服务，或限流某个服务来减轻系统压 ⼒，这就是服务降级。</p>
</li>
</ol>
<p>相同点： </p>
<ol>
<li><p>都是为了防⽌系统崩溃 </p>
</li>
<li><p>都让⽤户体验到某些功能暂时不可⽤</p>
</li>
</ol>
<p>不同点：熔断是下游服务故障触发的，降级是为了降低系统负载</p>
<h2 id="二十八、微服务相关"><a href="#二十八、微服务相关" class="headerlink" title="二十八、微服务相关"></a>二十八、微服务相关</h2><h3 id="1、SOA、分布式、微服务之间有什么关系和区别？"><a href="#1、SOA、分布式、微服务之间有什么关系和区别？" class="headerlink" title="1、SOA、分布式、微服务之间有什么关系和区别？"></a>1、SOA、分布式、微服务之间有什么关系和区别？</h3><ol>
<li><p>分布式架构是指将单体架构中的各个部分拆分，然后部署不同的机器或进程中去，SOA和微服务基 本上都是分布式架构的 </p>
</li>
<li><p>SOA是⼀种⾯向服务的架构，系统的所有服务都注册在总线上，当调⽤服务时，从总线上查找服务 信息，然后调⽤ </p>
</li>
<li><p>微服务是⼀种更彻底的⾯向服务的架构，将系统中各个功能个体抽成⼀个个⼩的应⽤程序，基本保 持⼀个应⽤对应的⼀个服务的架构</p>
</li>
</ol>
<h3 id="2、怎么拆分微服务？"><a href="#2、怎么拆分微服务？" class="headerlink" title="2、怎么拆分微服务？"></a>2、怎么拆分微服务？</h3><p>拆分微服务的时候，为了尽量保证微服务的稳定，会有⼀些基本的准则： </p>
<ol>
<li><p>微服务之间尽量不要有业务交叉。 </p>
</li>
<li><p>微服务之前只能通过接⼝进⾏服务调⽤，⽽不能绕过接⼝直接访问对⽅的数据。 </p>
</li>
<li><p>⾼内聚，低耦合。</p>
</li>
</ol>
<h3 id="3、怎样设计出⾼内聚、低耦合的微服务？"><a href="#3、怎样设计出⾼内聚、低耦合的微服务？" class="headerlink" title="3、怎样设计出⾼内聚、低耦合的微服务？"></a>3、怎样设计出⾼内聚、低耦合的微服务？</h3><p>⾼内聚低耦合，是⼀种从上⽽下指导微服务设计的⽅法。实现⾼内聚低耦合的⼯具主要有 同步的接⼝调 ⽤ 和 异步的事件驱动 两种⽅式</p>
<h3 id="4、有没有了解过DDD领域驱动设计？"><a href="#4、有没有了解过DDD领域驱动设计？" class="headerlink" title="4、有没有了解过DDD领域驱动设计？"></a>4、有没有了解过DDD领域驱动设计？</h3><p>什么是DDD： 在2004年，由Eric Evans提出了， DDD是⾯对软件复杂之道。Domain-Driven- Design –Tackling Complexity in the Heart of Software </p>
<p>⼤泥团： 不利于微服务的拆分。⼤泥团结构拆分出来的微服务依然是泥团机构，当服务业务逐渐复杂， 这个泥团⼜会膨胀成为⼤泥团。 </p>
<p>DDD只是⼀种⽅法论，没有⼀个稳定的技术框架。DDD要求领域是跟技术⽆关、跟存储⽆关、跟通信⽆关</p>
<h3 id="5、什么是中台？"><a href="#5、什么是中台？" class="headerlink" title="5、什么是中台？"></a>5、什么是中台？</h3><p>所谓中台，就是将各个业务线中可以复⽤的⼀些功能抽取出来，剥离个性，提取共性，形成⼀些可复⽤ 的组件。 </p>
<p>⼤体上，中台可以分为三类 业务中台、数据中台和技术中台。⼤数据杀熟-数据中台 </p>
<p>中台跟DDD结合： DDD会通过限界上下⽂将系统拆分成⼀个⼀个的领域， ⽽这种限界上下⽂，天⽣就 成了中台之间的逻辑屏障。 DDD在技术与资源调度⽅⾯都能够给中台建设提供不错的指导。 DDD分为战略设计和战术设计。 上层的战略设计能够很好的指导中台划分，下层的战术设计能够很好的指导微服务搭建。</p>
<h3 id="6、你的项⽬中是怎么保证微服务敏捷开发的？"><a href="#6、你的项⽬中是怎么保证微服务敏捷开发的？" class="headerlink" title="6、你的项⽬中是怎么保证微服务敏捷开发的？"></a>6、你的项⽬中是怎么保证微服务敏捷开发的？</h3><ul>
<li><p>开发运维⼀体化。 </p>
</li>
<li><p>敏捷开发： ⽬的就是为了提⾼团队的交付效率，快速迭代，快速试错 </p>
</li>
<li><p>每个⽉固定发布新版本，以分⽀的形式保存到代码仓库中。快速⼊职。任务⾯板、站⽴会议。团队 </p>
<p>⼈员灵活流动，同时形成各个专家代表 </p>
</li>
<li><p>测试环境- ⽣产环境 -开发测试环境SIT-集成测试环境-压测环境STR-预投产环境-⽣产环境PRD </p>
</li>
<li><p>晨会、周会、需求拆分会</p>
</li>
</ul>

                
            </div>
            <hr/>

            

    <div class="reprint" id="reprint-statement">
        
            <div class="reprint__author">
                <span class="reprint-meta" style="font-weight: bold;">
                    <i class="fas fa-user">
                        文章作者:
                    </i>
                </span>
                <span class="reprint-info">
                    <a href="/about" rel="external nofollow noreferrer">YangChao</a>
                </span>
            </div>
            <div class="reprint__type">
                <span class="reprint-meta" style="font-weight: bold;">
                    <i class="fas fa-link">
                        文章链接:
                    </i>
                </span>
                <span class="reprint-info">
                    <a href="https://monkey-chao.gitee.io/2022/08/10/java-mian-shi-ti-fen-bu-shi-wei-fu-wu-pian/">https://monkey-chao.gitee.io/2022/08/10/java-mian-shi-ti-fen-bu-shi-wei-fu-wu-pian/</a>
                </span>
            </div>
            <div class="reprint__notice">
                <span class="reprint-meta" style="font-weight: bold;">
                    <i class="fas fa-copyright">
                        版权声明:
                    </i>
                </span>
                <span class="reprint-info">
                    本博客所有文章除特別声明外，均采用
                    <a href="https://creativecommons.org/licenses/by/4.0/deed.zh" rel="external nofollow noreferrer" target="_blank">CC BY 4.0</a>
                    许可协议。转载请注明来源
                    <a href="/about" target="_blank">YangChao</a>
                    !
                </span>
            </div>
        
    </div>

    <script async defer>
      document.addEventListener("copy", function (e) {
        let toastHTML = '<span>复制成功，请遵循本文的转载规则</span><button class="btn-flat toast-action" onclick="navToReprintStatement()" style="font-size: smaller">查看</a>';
        M.toast({html: toastHTML})
      });

      function navToReprintStatement() {
        $("html, body").animate({scrollTop: $("#reprint-statement").offset().top - 80}, 800);
      }
    </script>



            <div class="tag_share" style="display: block;">
                <div class="post-meta__tag-list" style="display: inline-block;">
                    
                        <div class="article-tag">
                            
                                <a href="/tags/Java/">
                                    <span class="chip bg-color">Java</span>
                                </a>
                            
                                <a href="/tags/%E9%9D%A2%E8%AF%95/">
                                    <span class="chip bg-color">面试</span>
                                </a>
                            
                                <a href="/tags/%E5%88%86%E5%B8%83%E5%BC%8F%E4%B8%8E%E5%BE%AE%E6%9C%8D%E5%8A%A1/">
                                    <span class="chip bg-color">分布式与微服务</span>
                                </a>
                            
                        </div>
                    
                </div>
                <div class="post_share" style="zoom: 80%; width: fit-content; display: inline-block; float: right; margin: -0.15rem 0;">
                    <link rel="stylesheet" type="text/css" href="/libs/share/css/share.min.css">
<div id="article-share">

    
    <div class="social-share" data-sites="twitter,facebook,google,qq,qzone,wechat,weibo,douban,linkedin" data-wechat-qrcode-helper="<p>微信扫一扫即可分享！</p>"></div>
    <script src="/libs/share/js/social-share.min.js"></script>
    

    

</div>

                </div>
            </div>
            
                <style>
    #reward {
        margin: 40px 0;
        text-align: center;
    }

    #reward .reward-link {
        font-size: 1.4rem;
        line-height: 38px;
    }

    #reward .btn-floating:hover {
        box-shadow: 0 6px 12px rgba(0, 0, 0, 0.2), 0 5px 15px rgba(0, 0, 0, 0.2);
    }

    #rewardModal {
        width: 320px;
        height: 350px;
    }

    #rewardModal .reward-title {
        margin: 15px auto;
        padding-bottom: 5px;
    }

    #rewardModal .modal-content {
        padding: 10px;
    }

    #rewardModal .close {
        position: absolute;
        right: 15px;
        top: 15px;
        color: rgba(0, 0, 0, 0.5);
        font-size: 1.3rem;
        line-height: 20px;
        cursor: pointer;
    }

    #rewardModal .close:hover {
        color: #ef5350;
        transform: scale(1.3);
        -moz-transform:scale(1.3);
        -webkit-transform:scale(1.3);
        -o-transform:scale(1.3);
    }

    #rewardModal .reward-tabs {
        margin: 0 auto;
        width: 210px;
    }

    .reward-tabs .tabs {
        height: 38px;
        margin: 10px auto;
        padding-left: 0;
    }

    .reward-content ul {
        padding-left: 0 !important;
    }

    .reward-tabs .tabs .tab {
        height: 38px;
        line-height: 38px;
    }

    .reward-tabs .tab a {
        color: #fff;
        background-color: #ccc;
    }

    .reward-tabs .tab a:hover {
        background-color: #ccc;
        color: #fff;
    }

    .reward-tabs .wechat-tab .active {
        color: #fff !important;
        background-color: #22AB38 !important;
    }

    .reward-tabs .alipay-tab .active {
        color: #fff !important;
        background-color: #019FE8 !important;
    }

    .reward-tabs .reward-img {
        width: 210px;
        height: 210px;
    }
</style>

<div id="reward">
    <a href="#rewardModal" class="reward-link modal-trigger btn-floating btn-medium waves-effect waves-light red">赏</a>

    <!-- Modal Structure -->
    <div id="rewardModal" class="modal">
        <div class="modal-content">
            <a class="close modal-close"><i class="fas fa-times"></i></a>
            <h4 class="reward-title">你的赏识是我前进的动力</h4>
            <div class="reward-content">
                <div class="reward-tabs">
                    <ul class="tabs row">
                        <li class="tab col s6 alipay-tab waves-effect waves-light"><a href="#alipay">支付宝</a></li>
                        <li class="tab col s6 wechat-tab waves-effect waves-light"><a href="#wechat">微 信</a></li>
                    </ul>
                    <div id="alipay">
                        <img src="/medias/reward/alipay.jpg" class="reward-img" alt="支付宝打赏二维码">
                    </div>
                    <div id="wechat">
                        <img src="/medias/reward/wechat.png" class="reward-img" alt="微信打赏二维码">
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>

<script>
    $(function () {
        $('.tabs').tabs();
    });
</script>

            
        </div>
    </div>

    

    

    

    
    <div class="livere-card card" data-aos="fade-up">
    <!-- 来必力City版安装代码 -->
    <div id="lv-container" class="card-content" data-id="city" data-uid="">
        <script type="text/javascript">
            (function (d, s) {
                let j, e = d.getElementsByTagName(s)[0];
                if (typeof LivereTower === 'function') {
                    return;
                }

                j = d.createElement(s);
                j.src = 'https://cdn-city.livere.com/js/embed.dist.js';
                j.async = true;

                e.parentNode.insertBefore(j, e);
            })(document, 'script');
        </script>
        <noscript>为正常使用来必力评论功能请激活JavaScript。</noscript>
    </div>
    <!-- City版安装代码已完成 -->
</div>
    

    
        <style>
    .valine-card {
        margin: 1.5rem auto;
    }

    .valine-card .card-content {
        padding: 20px 20px 5px 20px;
    }

    #vcomments textarea {
        box-sizing: border-box;
        background: url("/medias/comment_bg.png") 100% 100% no-repeat;
    }

    #vcomments p {
        margin: 2px 2px 10px;
        font-size: 1.05rem;
        line-height: 1.78rem;
    }

    #vcomments blockquote p {
        text-indent: 0.2rem;
    }

    #vcomments a {
        padding: 0 2px;
        color: #4cbf30;
        font-weight: 500;
        text-decoration: none;
    }

    #vcomments img {
        max-width: 100%;
        height: auto;
        cursor: pointer;
    }

    #vcomments ol li {
        list-style-type: decimal;
    }

    #vcomments ol,
    ul {
        display: block;
        padding-left: 2em;
        word-spacing: 0.05rem;
    }

    #vcomments ul li,
    ol li {
        display: list-item;
        line-height: 1.8rem;
        font-size: 1rem;
    }

    #vcomments ul li {
        list-style-type: disc;
    }

    #vcomments ul ul li {
        list-style-type: circle;
    }

    #vcomments table, th, td {
        padding: 12px 13px;
        border: 1px solid #dfe2e5;
    }

    #vcomments table, th, td {
        border: 0;
    }

    table tr:nth-child(2n), thead {
        background-color: #fafafa;
    }

    #vcomments table th {
        background-color: #f2f2f2;
        min-width: 80px;
    }

    #vcomments table td {
        min-width: 80px;
    }

    #vcomments h1 {
        font-size: 1.85rem;
        font-weight: bold;
        line-height: 2.2rem;
    }

    #vcomments h2 {
        font-size: 1.65rem;
        font-weight: bold;
        line-height: 1.9rem;
    }

    #vcomments h3 {
        font-size: 1.45rem;
        font-weight: bold;
        line-height: 1.7rem;
    }

    #vcomments h4 {
        font-size: 1.25rem;
        font-weight: bold;
        line-height: 1.5rem;
    }

    #vcomments h5 {
        font-size: 1.1rem;
        font-weight: bold;
        line-height: 1.4rem;
    }

    #vcomments h6 {
        font-size: 1rem;
        line-height: 1.3rem;
    }

    #vcomments p {
        font-size: 1rem;
        line-height: 1.5rem;
    }

    #vcomments hr {
        margin: 12px 0;
        border: 0;
        border-top: 1px solid #ccc;
    }

    #vcomments blockquote {
        margin: 15px 0;
        border-left: 5px solid #42b983;
        padding: 1rem 0.8rem 0.3rem 0.8rem;
        color: #666;
        background-color: rgba(66, 185, 131, .1);
    }

    #vcomments pre {
        font-family: monospace, monospace;
        padding: 1.2em;
        margin: .5em 0;
        background: #272822;
        overflow: auto;
        border-radius: 0.3em;
        tab-size: 4;
    }

    #vcomments code {
        font-family: monospace, monospace;
        padding: 1px 3px;
        font-size: 0.92rem;
        color: #e96900;
        background-color: #f8f8f8;
        border-radius: 2px;
    }

    #vcomments pre code {
        font-family: monospace, monospace;
        padding: 0;
        color: #e8eaf6;
        background-color: #272822;
    }

    #vcomments pre[class*="language-"] {
        padding: 1.2em;
        margin: .5em 0;
    }

    #vcomments code[class*="language-"],
    pre[class*="language-"] {
        color: #e8eaf6;
    }

    #vcomments [type="checkbox"]:not(:checked), [type="checkbox"]:checked {
        position: inherit;
        margin-left: -1.3rem;
        margin-right: 0.4rem;
        margin-top: -1px;
        vertical-align: middle;
        left: unset;
        visibility: visible;
    }

    #vcomments b,
    strong {
        font-weight: bold;
    }

    #vcomments dfn {
        font-style: italic;
    }

    #vcomments small {
        font-size: 85%;
    }

    #vcomments cite {
        font-style: normal;
    }

    #vcomments mark {
        background-color: #fcf8e3;
        padding: .2em;
    }

    #vcomments table, th, td {
        padding: 12px 13px;
        border: 1px solid #dfe2e5;
    }

    table tr:nth-child(2n), thead {
        background-color: #fafafa;
    }

    #vcomments table th {
        background-color: #f2f2f2;
        min-width: 80px;
    }

    #vcomments table td {
        min-width: 80px;
    }

    #vcomments [type="checkbox"]:not(:checked), [type="checkbox"]:checked {
        position: inherit;
        margin-left: -1.3rem;
        margin-right: 0.4rem;
        margin-top: -1px;
        vertical-align: middle;
        left: unset;
        visibility: visible;
    }
</style>

<div class="card valine-card" data-aos="fade-up">
    <div class="comment_headling" style="font-size: 20px; font-weight: 700; position: relative; padding-left: 20px; top: 15px; padding-bottom: 5px;">
        <i class="fas fa-comments fa-fw" aria-hidden="true"></i>
        <span>评论</span>
    </div>
    <div id="vcomments" class="card-content" style="display: grid">
    </div>
</div>

<script src="/libs/valine/av-min.js"></script>
<script src="/libs/valine/Valine.min.js"></script>
<script>
    new Valine({
        el: '#vcomments',
        appId: '1543373971',
        appKey: '111111',
        notify: 'false' === 'true',
        verify: 'false' === 'true',
        visitor: 'true' === 'true',
        avatar: 'mm',
        pageSize: '10',
        lang: 'zh-cn',
        placeholder: 'just go go'
    });
</script>

<!--酷Q推送-->


    

    
        <style>
    .mvaline-card {
        margin: 1.5rem auto;
    }

    .mvaline-card .card-content {
        padding: 20px 20px 5px 20px;
    }
</style>

<div class="card mvaline-card" data-aos="fade-up">
    <div class="comment_headling" style="font-size: 20px; font-weight: 700; position: relative; padding-left: 20px; top: 15px; padding-bottom: 5px;">
        <i class="fas fa-comments fa-fw" aria-hidden="true"></i>
        <span>评论</span>
    </div>
    <div id="mvcomments" class="card-content" style="display: grid">
    </div>
</div>

<script src="/libs/minivaline/MiniValine.js"></script>
<script>
    new MiniValine(Object.assign({"enable":true,"serverURL":"https://minivaline.your-domain.top"}, {
	  el: '#mvcomments',
    }));
</script>

    

    

    

    

    

<article id="prenext-posts" class="prev-next articles">
    <div class="row article-row">
        
        <div class="article col s12 m6" data-aos="fade-up">
            <div class="article-badge left-badge text-color">
                <i class="fas fa-chevron-left"></i>&nbsp;上一篇</div>
            <div class="card">
                <a href="/2022/08/10/java-mian-shi-ti-xiao-xi-dui-lie-pian/">
                    <div class="card-image">
                        
                        
                        <img src="/medias/featureimages/2.jpg" class="responsive-img" alt="Java面试题（消息队列篇）">
                        
                        <span class="card-title">Java面试题（消息队列篇）</span>
                    </div>
                </a>
                <div class="card-content article-content">
                    <div class="summary block-with-text">
                        
                            Java面试消息队列题型相关讲解
                        
                    </div>
                    <div class="publish-info">
                        <span class="publish-date">
                            <i class="far fa-clock fa-fw icon-date"></i>2022-08-10
                        </span>
                        <span class="publish-author">
                            
                            <i class="fas fa-bookmark fa-fw icon-category"></i>
                            
                            <a href="/categories/%E9%9D%A2%E8%AF%95%E5%AE%9D%E5%85%B8/" class="post-category">
                                    面试宝典
                                </a>
                            
                            
                        </span>
                    </div>
                </div>
                
                <div class="card-action article-tags">
                    
                    <a href="/tags/Java/">
                        <span class="chip bg-color">Java</span>
                    </a>
                    
                    <a href="/tags/%E9%9D%A2%E8%AF%95/">
                        <span class="chip bg-color">面试</span>
                    </a>
                    
                    <a href="/tags/%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97/">
                        <span class="chip bg-color">消息队列</span>
                    </a>
                    
                </div>
                
            </div>
        </div>
        
        
        <div class="article col s12 m6" data-aos="fade-up">
            <div class="article-badge right-badge text-color">
                下一篇&nbsp;<i class="fas fa-chevron-right"></i>
            </div>
            <div class="card">
                <a href="/2022/08/10/java-mian-shi-ti-redis-pian/">
                    <div class="card-image">
                        
                        
                        <img src="/medias/featureimages/0.jpg" class="responsive-img" alt="Java面试题（Redis篇）">
                        
                        <span class="card-title">Java面试题（Redis篇）</span>
                    </div>
                </a>
                <div class="card-content article-content">
                    <div class="summary block-with-text">
                        
                            Java面试Redis题型相关讲解
                        
                    </div>
                    <div class="publish-info">
                            <span class="publish-date">
                                <i class="far fa-clock fa-fw icon-date"></i>2022-08-10
                            </span>
                        <span class="publish-author">
                            
                            <i class="fas fa-bookmark fa-fw icon-category"></i>
                            
                            <a href="/categories/%E9%9D%A2%E8%AF%95%E5%AE%9D%E5%85%B8/" class="post-category">
                                    面试宝典
                                </a>
                            
                            
                        </span>
                    </div>
                </div>
                
                <div class="card-action article-tags">
                    
                    <a href="/tags/Redis/">
                        <span class="chip bg-color">Redis</span>
                    </a>
                    
                    <a href="/tags/Java/">
                        <span class="chip bg-color">Java</span>
                    </a>
                    
                    <a href="/tags/%E9%9D%A2%E8%AF%95/">
                        <span class="chip bg-color">面试</span>
                    </a>
                    
                </div>
                
            </div>
        </div>
        
    </div>
</article>

</div>


<script>
    $('#articleContent').on('copy', function (e) {
        // IE8 or earlier browser is 'undefined'
        if (typeof window.getSelection === 'undefined') return;

        var selection = window.getSelection();
        // if the selection is short let's not annoy our users.
        if (('' + selection).length < Number.parseInt('120')) {
            return;
        }

        // create a div outside of the visible area and fill it with the selected text.
        var bodyElement = document.getElementsByTagName('body')[0];
        var newdiv = document.createElement('div');
        newdiv.style.position = 'absolute';
        newdiv.style.left = '-99999px';
        bodyElement.appendChild(newdiv);
        newdiv.appendChild(selection.getRangeAt(0).cloneContents());

        // we need a <pre> tag workaround.
        // otherwise the text inside "pre" loses all the line breaks!
        if (selection.getRangeAt(0).commonAncestorContainer.nodeName === 'PRE' || selection.getRangeAt(0).commonAncestorContainer.nodeName === 'CODE') {
            newdiv.innerHTML = "<pre>" + newdiv.innerHTML + "</pre>";
        }

        var url = document.location.href;
        newdiv.innerHTML += '<br />'
            + '来源: Angus<br />'
            + '文章作者: YangChao<br />'
            + '文章链接: <a href="' + url + '">' + url + '</a><br />'
            + '本文章著作权归作者所有，任何形式的转载都请注明出处。';

        selection.selectAllChildren(newdiv);
        window.setTimeout(function () {bodyElement.removeChild(newdiv);}, 200);
    });
</script>


<!-- 代码块功能依赖 -->
<script type="text/javascript" src="/libs/codeBlock/codeBlockFuction.js"></script>

<!-- 代码语言 -->

<script type="text/javascript" src="/libs/codeBlock/codeLang.js"></script>


<!-- 代码块复制 -->

<script type="text/javascript" src="/libs/codeBlock/codeCopy.js"></script>


<!-- 代码块收缩 -->

<script type="text/javascript" src="/libs/codeBlock/codeShrink.js"></script>


    </div>
    <div id="toc-aside" class="expanded col l3 hide-on-med-and-down">
        <div class="toc-widget card" style="background-color: white;">
            <div class="toc-title"><i class="far fa-list-alt"></i>&nbsp;&nbsp;目录</div>
            <div id="toc-content"></div>
        </div>
    </div>
</div>

<!-- TOC 悬浮按钮. -->

<div id="floating-toc-btn" class="hide-on-med-and-down">
    <a class="btn-floating btn-large bg-color">
        <i class="fas fa-list-ul"></i>
    </a>
</div>


<script src="/libs/tocbot/tocbot.min.js"></script>
<script>
    $(function () {
        tocbot.init({
            tocSelector: '#toc-content',
            contentSelector: '#articleContent',
            headingsOffset: -($(window).height() * 0.4 - 45),
            collapseDepth: Number('0'),
            headingSelector: 'h2, h3, h4'
        });

        // Set scroll toc fixed.
        let tocHeight = parseInt($(window).height() * 0.4 - 64);
        let $tocWidget = $('.toc-widget');
        $(window).scroll(function () {
            let scroll = $(window).scrollTop();
            /* add post toc fixed. */
            if (scroll > tocHeight) {
                $tocWidget.addClass('toc-fixed');
            } else {
                $tocWidget.removeClass('toc-fixed');
            }
        });

        
        /* 修复文章卡片 div 的宽度. */
        let fixPostCardWidth = function (srcId, targetId) {
            let srcDiv = $('#' + srcId);
            if (srcDiv.length === 0) {
                return;
            }

            let w = srcDiv.width();
            if (w >= 450) {
                w = w + 21;
            } else if (w >= 350 && w < 450) {
                w = w + 18;
            } else if (w >= 300 && w < 350) {
                w = w + 16;
            } else {
                w = w + 14;
            }
            $('#' + targetId).width(w);
        };

        // 切换TOC目录展开收缩的相关操作.
        const expandedClass = 'expanded';
        let $tocAside = $('#toc-aside');
        let $mainContent = $('#main-content');
        $('#floating-toc-btn .btn-floating').click(function () {
            if ($tocAside.hasClass(expandedClass)) {
                $tocAside.removeClass(expandedClass).hide();
                $mainContent.removeClass('l9');
            } else {
                $tocAside.addClass(expandedClass).show();
                $mainContent.addClass('l9');
            }
            fixPostCardWidth('artDetail', 'prenext-posts');
        });
        
    });
</script>

    

</main>




    <footer class="page-footer bg-color">
    

    <div class="container row center-align"
         style="margin-bottom: 0px !important;">
        <div class="col s12 m8 l8 copy-right">
            Copyright&nbsp;&copy;
            
                <span id="year">2019-2023</span>
            
            <a href="/about" target="_blank">YangChao</a>
<!--             |&nbsp;Powered by&nbsp;<a href="https://hexo.io/" target="_blank">Hexo</a>
            |&nbsp;Theme&nbsp;<a href="https://github.com/Monkey-chao/Monkey-chao.github.io.git" target="_blank">Matery</a> -->
            <br>
            
                &nbsp;<i class="fas fa-chart-area"></i>&nbsp;站点总字数:&nbsp;<span
                        class="white-color">460.9k</span>
            
            
            
                
            
            
                <span id="busuanzi_container_site_pv">
                &nbsp;|&nbsp;<i class="far fa-eye"></i>&nbsp;总访问量:&nbsp;
                    <span id="busuanzi_value_site_pv" class="white-color"></span>
            </span>
            
            
                <span id="busuanzi_container_site_uv">
                &nbsp;|&nbsp;<i class="fas fa-users"></i>&nbsp;总访问人数:&nbsp;
                    <span id="busuanzi_value_site_uv" class="white-color"></span>
            </span>
            
            <br>

            <!-- 运行天数提醒. -->
            
            <br>
            
        </div>
<!--         <div class="col s12 m4 l4 social-link social-statis">
    <a href="https://github.com/Monkey-chao/Monkey-chao.github.io.git" class="tooltipped" target="_blank" data-tooltip="访问我的GitHub" data-position="top" data-delay="50">
        <i class="fab fa-github"></i>
    </a>




<!-- 

 -->


    <a href="tencent://AddContact/?fromId=50&fromSubId=1&subcmd=all&uin=1543373971" class="tooltipped" target="_blank" data-tooltip="QQ联系我: 1543373971" data-position="top" data-delay="50">
        <i class="fab fa-qq"></i>
    </a>


<!-- 




    <a href="/atom.xml" class="tooltipped" target="_blank" data-tooltip="RSS 订阅" data-position="top" data-delay="50">
        <i class="fas fa-rss"></i>
    </a>

 --></div>
 -->     </div>
</footer>

<div class="progress-bar"></div>


    <!-- 搜索遮罩框 -->
<div id="searchModal" class="modal">
    <div class="modal-content">
        <div class="search-header">
            <span class="title"><i class="fas fa-search"></i>&nbsp;&nbsp;搜索</span>
            <input type="search" id="searchInput" name="s" placeholder="请输入搜索的关键字"
                   class="search-input">
        </div>
        <div id="searchResult"></div>
    </div>
</div>

<script type="text/javascript">
$(function () {
    var searchFunc = function (path, search_id, content_id) {
        'use strict';
        $.ajax({
            url: path,
            dataType: "xml",
            success: function (xmlResponse) {
                // get the contents from search data
                var datas = $("entry", xmlResponse).map(function () {
                    return {
                        title: $("title", this).text(),
                        content: $("content", this).text(),
                        url: $("url", this).text()
                    };
                }).get();
                var $input = document.getElementById(search_id);
                var $resultContent = document.getElementById(content_id);
                $input.addEventListener('input', function () {
                    var str = '<ul class=\"search-result-list\">';
                    var keywords = this.value.trim().toLowerCase().split(/[\s\-]+/);
                    $resultContent.innerHTML = "";
                    if (this.value.trim().length <= 0) {
                        return;
                    }
                    // perform local searching
                    datas.forEach(function (data) {
                        var isMatch = true;
                        var data_title = data.title.trim().toLowerCase();
                        var data_content = data.content.trim().replace(/<[^>]+>/g, "").toLowerCase();
                        var data_url = data.url;
                        data_url = data_url.indexOf('/') === 0 ? data.url : '/' + data_url;
                        var index_title = -1;
                        var index_content = -1;
                        var first_occur = -1;
                        // only match artiles with not empty titles and contents
                        if (data_title !== '' && data_content !== '') {
                            keywords.forEach(function (keyword, i) {
                                index_title = data_title.indexOf(keyword);
                                index_content = data_content.indexOf(keyword);
                                if (index_title < 0 && index_content < 0) {
                                    isMatch = false;
                                } else {
                                    if (index_content < 0) {
                                        index_content = 0;
                                    }
                                    if (i === 0) {
                                        first_occur = index_content;
                                    }
                                }
                            });
                        }
                        // show search results
                        if (isMatch) {
                            str += "<li><a href='" + data_url + "' class='search-result-title'>" + data_title + "</a>";
                            var content = data.content.trim().replace(/<[^>]+>/g, "");
                            if (first_occur >= 0) {
                                // cut out 100 characters
                                var start = first_occur - 20;
                                var end = first_occur + 80;
                                if (start < 0) {
                                    start = 0;
                                }
                                if (start === 0) {
                                    end = 100;
                                }
                                if (end > content.length) {
                                    end = content.length;
                                }
                                var match_content = content.substr(start, end);
                                // highlight all keywords
                                keywords.forEach(function (keyword) {
                                    var regS = new RegExp(keyword, "gi");
                                    match_content = match_content.replace(regS, "<em class=\"search-keyword\">" + keyword + "</em>");
                                });

                                str += "<p class=\"search-result\">" + match_content + "...</p>"
                            }
                            str += "</li>";
                        }
                    });
                    str += "</ul>";
                    $resultContent.innerHTML = str;
                });
            }
        });
    };

    searchFunc('/search.xml', 'searchInput', 'searchResult');
});
</script>

    <!-- 回到顶部按钮 -->
<div id="backTop" class="top-scroll">
    <a class="btn-floating btn-large waves-effect waves-light" href="#!">
        <i class="fas fa-arrow-up"></i>
    </a>
</div>


    <script src="/libs/materialize/materialize.min.js"></script>
    <script src="/libs/masonry/masonry.pkgd.min.js"></script>
    <script src="/libs/aos/aos.js"></script>
    <script src="/libs/scrollprogress/scrollProgress.min.js"></script>
    <script src="/libs/lightGallery/js/lightgallery-all.min.js"></script>
    <script src="/js/matery.js"></script>

    

    
        
        <script type="text/javascript">
            // 只在桌面版网页启用特效
            var windowWidth = $(window).width();
            if (windowWidth > 768) {
                document.write('<script type="text/javascript" src="/libs/others/sakura.js"><\/script>');
            }
        </script>
    

    <!-- 雪花特效 -->
    

    <!-- 鼠标星星特效 -->
    

    

    <!-- Baidu Analytics -->

    <!-- Baidu Push -->

<script>
    (function () {
        var bp = document.createElement('script');
        var curProtocol = window.location.protocol.split(':')[0];
        if (curProtocol === 'https') {
            bp.src = 'https://zz.bdstatic.com/linksubmit/push.js';
        } else {
            bp.src = 'http://push.zhanzhang.baidu.com/push.js';
        }
        var s = document.getElementsByTagName("script")[0];
        s.parentNode.insertBefore(bp, s);
    })();
</script>

    
    <script src="/libs/others/clicklove.js" async="async"></script>
    
    
    <script async src="/libs/others/busuanzi.pure.mini.js"></script>
    

    

    

    <!--腾讯兔小巢-->
    
    

    

    

    
    <script src="/libs/instantpage/instantpage.js" type="module"></script>
    

</body>

</html>
